Handle the parameters of a tail-rec LabelDef in a more principled way.

In particular, we do not patch them as mutable by default, only to
re-patch them as immutable if they are not mutated. Instead, we keep
their original isMutable flag as the default, and we patch immutable
locals as mutable if they are mutated.
Fix #1148: generalize our tail-call transform to more LabelDefs.

The translation of the LabelDef and Apply of tail-recursive calls
is generalized to support arbitrary LabelDefs, as long as all
label-applies to it are performed from within its body.

In addition to being a nice generalization, this fixes #1148,
because label-defs for while loops transformed in weird ways by
scoverage now fall under this generalized transformation.
Merge pull request #1150 from sjrd/fix-crash-with-scoverage

Fix #1148: compiler crash with scoverage
Fix #1153: Inlineable classes break with dependent fields.
Allow aliasing to cross the inlineable class constructor barrier.

Basically, this allows to keep information about constants or
aliasing assigned to fields of an inlineable class, for use with
the instance returned by the constructor.
Lift the restriction on aliasing of InlineableClassBeingConstructed.

The only problem is if it is aliased to a field of itself. Otherwise,
scoping rules will prevent any bad thing from happening.
Merge pull request #1152 from sjrd/improve-inlineable-classes

Improve inlineable classes
Optimize varargs by using js.WrappedArray instead of scm.WrappedArray.
Merge pull request #1151 from sjrd/opt-varargs

Optimize varargs with js.WrappedArray.
Add direct support for Long in the IR.

This basically delays the translation of Longs to RuntimeLongs from
the compiler to the desugaring. This brings the following benefits:

* It relieves the compiler from the knowledge of RuntimeLong.
* It makes the IR independent of the implementation of Longs (so we
  may change it in the future in a binary-compatible way).
* It allows the optimizer to reason about Longs, in particular to
  constant-fold them.

This prompted several cleanups in the whole Long implementation:
* Incorporate fromString() directly into j.l.Long.parseLong().
* Since done in desugar, "inline by hand" the methods of the
  companion of RuntimeLong. This basically means call directly
  whatever they were forwarding to.
* Hence, there was no method left in this companion, so I could
  merge RuntimeLongImpl back into it, as it used to be.

The whole thing is much cleaner now.
Constant-fold Matches.
Fix {ir,js}.Block.toString().
More constant folding.
Mark Range and Range.Inclusive as inlineable classes.

This removes *all* the overhead if all 3 parameters of the
range are constants. For example,

  for (i <- 0 until 10 by 2) { ... }

If the step is either 1 or -1, and either start or end is
constant (very common case), then almost all the overhead is
removed, except for 3 Long operations. For example:

  for (i <- 0 until n) { ... }
wip