Accidentally using different types for the lower and upper endpoint produces a `ClassCastException` when validating that the lower endpoint isn't above the upper endpoint. This is a little surprising.

For example, the following:

```java
Range<? extends Number> range = Range.closedOpen(0, 1.0);
```

results in

```
java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.Integer
        at java.lang.Integer.compareTo(Integer.java:52)
        at com.google.common.collect.Range.compareOrThrow(Range.java:690)
        at com.google.common.collect.Cut.compareTo(Cut.java:77)
        at com.google.common.collect.Range.<init>(Range.java:349)
        at com.google.common.collect.Range.create(Range.java:155)
        at com.google.common.collect.Range.closedOpen(Range.java:189)
```

(In the actual code I'm looking at, the `range` variable is a function parameter that must accept numeric ranges of different types, so it's less weird than it looks here.)

Now, the range produced here _is_ completely invalid, and there's no way that the compiler can check this (because we can't express that the two bounds parameters must be the same concrete type, or at worst be mutually comparable).

However, it would be nice if `Range.compareOrThrow()` caught `ClassCastException` and returned a clearer message, or just chained the CCE onto the "Invalid range" `IllegalArgumentException` it can already throw.

I note that `Range.compareOrThrow()` has a "may throw CCE" comment, but the only place that this exception is mentioned otherwise is in the Javadoc for `Range.encloseAll()` and a comment in `Range.contains()`, both of which are talking about their function arguments.
} else if (lowerCmp <= 0 && upperCmp >= 0) {
      return connectedRange;
    } else {
      Cut<C> newLower = (lowerCmp >= 0) ? lowerBound : connectedRange.lowerBound;
      Cut<C> newUpper = (upperCmp <= 0) ? upperBound : connectedRange.upperBound;
      return create(newLower, newUpper);
    }
  }
  /**
   * Returns the maximal range lying between this range and {@code otherRange}, if such a range
   * exists. The resulting range may be empty if the two ranges are adjacent but non-overlapping.
   *
   * <p>For example, the gap of {@code [1..5]} and {@code (7..10)} is {@code (5..7]}. The resulting
   * range may be empty; for example, the gap between {@code [1..5)} {@code [5..7)} yields the empty
   * range {@code [5..5)}.
   *
   * <p>The gap exists if and only if the two ranges are either disconnected or immediately adjacent
   * (any intersection must be an empty range).
   *
   * <p>The gap operation is commutative.
   *
   * @throws IllegalArgumentException if this range and {@code otherRange} have a nonempty
   *     intersection
   * @since 27.0
   */
  public Range<C> gap(Range<C> otherRange) {
    boolean isThisFirst = this.lowerBound.compareTo(otherRange.lowerBound) < 0;
    Range<C> firstRange = isThisFirst ? this : otherRange;
    Range<C> secondRange = isThisFirst ? otherRange : this;
    return create(firstRange.upperBound, secondRange.lowerBound);