Trying to throw an exception at the time of inserting the element would require scanning all of the existing elements in the map to verify that they are comparable with the element you are inserting, which would be terrible for performance and scalability. Similarly, catching the exception when you cause a comparison to happen and translating it to `nil` would add overhead that would be wasted on every correct use of the map. This is not the only case in Clojure where you need to understand the actual contracts of the data structures involved, and use them correctly or end up with unexpected results, in favor of performance. (Not to mention that special Clojure-oriented implementations of all the underlying Java classes would be required to add these features.)
In this case, the data structure involved is the Java `SortedMap` interface. Here is what is the second paragraph of the JavaDoc says:
All keys inserted into a sorted map must implement the `Comparable` interface (or be accepted by the specified comparator). Furthermore, all such keys must be mutually comparable: `k1.compareTo(k2)` (or `comparator.compare(k1, k2))` must not throw a `ClassCastException` for any keys `k1` and `k2` in the sorted map. Attempts to violate this restriction will cause the offending method or constructor invocation to throw a `ClassCastException`.
As you get deeper in JVM Clojure, you are inevitably going to need to learn details about the Java class libraries that it builds on and interoperates with. That said, a link to this JavaDoc and perhaps a summary/translation of it into Clojure terms could be useful in the Clojure doc string.