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.
}
  /**
   * Returns the minimal range that {@linkplain #encloses encloses} both this range and {@code
   * other}. For example, the span of {@code [1..3]} and {@code (5..7)} is {@code [1..7)}.
   *
   * <p><i>If</i> the input ranges are {@linkplain #isConnected connected}, the returned range can
   * also be called their <i>union</i>. If they are not, note that the span might contain values
   * that are not contained in either input range.
   *
   * <p>Like {@link #intersection(Range) intersection}, this operation is commutative, associative
   * and idempotent. Unlike it, it is always well-defined for any two input ranges.
   */
  public Range<C> span(Range<C> other) {
    int lowerCmp = lowerBound.compareTo(other.lowerBound);
    int upperCmp = upperBound.compareTo(other.upperBound);
    if (lowerCmp <= 0 && upperCmp >= 0) {
      return this;
    } else if (lowerCmp >= 0 && upperCmp <= 0) {
      return other;
    } else {
      Cut<C> newLower = (lowerCmp <= 0) ? lowerBound : other.lowerBound;
      Cut<C> newUpper = (upperCmp >= 0) ? upperBound : other.upperBound;
      return create(newLower, newUpper);
    }
  }
  /**
   * Returns the canonical form of this range in the given domain. The canonical form has the
   * following properties:
   *
   * <ul>