It turns out the computation we did in the non-negative case also
works for the negative case. The proof relies on elementary
properties of the two's complement representation.

I don't know how I never saw this before. To make things worse, it
seems that Kotlin and J2CL knew all along, and I never realized
when skimming through their implementations either.

Since conversions of signed longs to doubles is in fact no more
expensive than the unsigned longs, we can take shorter paths for
values that fit in the *signed* safe range.

This applies to the conversions to string (including in the
javalib) and to float.

It could also apply to signed division and remainder. However,
benchmarks suggest that doing so makes it slower. The trouble is
that we then need a signed double-to-long conversion for the
result, and that appears to be slower than performing the 3 sign
adjustments.