Get rid of the box/unbox helpers for Chars.

Basically, java.lang.Character becomes a completely regular
class, that the IR and the tools do not handle in any special
way.
Replace unbox helpers by a dedicated IR node.
Get rid of the systemArraycopy helper by making it an intrinsic.

Intrinsics are a bit like primitives, except that they are special
for the *optimizer*, not for the compiler. This allows to defer
their optimization to link time, if a correct (but non-optimal)
implementation can be written in Scala.js.

This is the case for System.arraycopy, which is the first
primitive to be turned into an intrinsic.

We call these things intrinsics because they are very similar
to JVM intrinsics: methods with a correct implementation in either
pure Java or through JNI, but that the optimizing compilers know
how to handle better.
Improve the implementation of Long.to{Binary,Hex,Octal}String.

It does not use Formatter anymore, and does not require to drop
the leading 0's after the fact.
Turn methods of the j.l.Long companion object into intrinsics.

This allows to get rid of the hack that j.l.Long needed to know
about RuntimeLongs, and in general that Longs are implemented
with this class.
Turn conversions to/from TypedArrays into intrinsics.
Turn System.identityHashCode into an intrinsic.
Get rid of the checkNonNull helper, replace it by codegen.

There was only one place in the compiler where this helper was
used, and it's a rare case. So I simply replaced it by codegen
that does the same thing.
Fix unit test for DataInputStream.readLong().

It's not good to give Longs to Jasmine for comparisons, because
they are converted to Doubles.
Implement primitive conversions to/from js.Any in user-space.

With the semantics introduced in 0.5.0, they can be implemented
with regular .asInstanceOfs. And with the optimizer, the methods
can be inlined. So we don't need the primitives anymore.
Turn the helper environmentInfo into an IR node.

Because it seems there's nothing else we can do about it.
Turn the helper propertiesOf into an intrinsic.

This required to loosen a little bit the guarantees about the
ordering of the properties. But given how little specified this
is for the for-in loop itself anyway, it should not affect any
real code.
Tighten checksizes.
Implement String methods in an object rather than as a trait.

This fixes the mess that RuntimeString was as a trait. It was
very hacky and very dependent on the implementation details.

Now, RuntimeString is only an object, and its methods take an
explicit `thiz` parameter that stands for the String being
operated on.

Most methods are inlineable one-liners. For the others, Closure
turn them into static methods anyway.