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.
PreTransRecordTrees are likely optimizable.
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.
Fix #1157: Negative number literals should be printed with parentheses.
Fix #1155: Int unary -.
Remove the absurd unary Int_+ and Double_+ from the IR.

They are always no-ops anyway.
Merge pull request #1156 from sjrd/fix-int-unary-minus

Fix Int unary -
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.
Merge pull request #1159 from sjrd/long-in-ir

Add direct support for Long in the IR.
Constant-fold Matches.
Fix {ir,js}.Block.toString().
More constant folding with operands disappearing.

Their side-effects must be preserved.
Insane rewritings of expressions involving Longs.

To remove as many Long operations as possible, and in particular
turn them into Int operations where applicable.

These insane rewritings are motivated by the shapes of expressions
we get if we inline Ranges (which is not yet done).