Use CPS in the optimizer to deal with PreTransforms.

Instead of having a method
  def pretransformExpr(tree: Tree): PreTransform
which in direct style, we now have a method
  def pretransformExpr(tree: Tree)(
      cont: PreTransform => Tree): Tree
which works in continuation passing style.
Essentially it means: pretransform this tree, and then call
this continuation with the resulting PreTransform. The result
of the continuation is your result.

This allows to make optimistic optimization choices, i.e.,
tryOrRollback, at exactly the right place: the current
continuation is called once in the try part, and, if it fails,
once again in the fallback case. The PreTransforms can contain
a reference to the appropriate cancelFun: since PreTransforms
are only available in the continuations that receive them, and
these continuations have been called with the try part on the
call stack, it is always allowed to call the cancelFun.
Disable optimistic optimizations if there are too many rollbacks.

This is a protection mechanism against the potential exponential
blow-up of tryOrRollback, in the general case. If, during the
optimization of a given method, more than 256 rollbacks occur,
then we bail out completely, cancel everything, and start the
optimization of the method from scratch, but this time disabling
any optimistic optimizations.
Inlineable classes optimization.

Given some constructor call such as
  new SomeClass(params)
where SomeClass is an inlineable class, the optimizer will
optimistically try to inline the class as a record, which
basically means that its fields become local variables.

If the reference to the instance escapes the method in any
way (typically because it is returned, or passed as a
receiver or an argument of a non-inlined method), then the
optimization is rollbacked.

There are several typical cases of inlineable classes in
code produced by Scala:
* IntRefs and co, which externalize local vars captured by
  lambdas. If the lambda is inlined, they can be inlined
  back as well.
* Tuples used as multi-value ifs or matches.
* Anonymous function classes not optimized as closures by the
  compiler, but still inlineable at link time.
* ArrayOps classes.

The optimization is also useful for small datastructures used
a lot in local computations. This is typical of mathematical
constructs, e.g., 3D vectors.
Merge pull request #858 from sjrd/clean-inlineable-classes

Inlineable classes
Fix #853: The Analyzer should treat RuntimeLong as a subclass of j.l.Long.
Merge pull request #866 from sjrd/runtimelong-subclass-of-jllong

Fix #853: The Analyzer should treat RuntimeLong as a subclass of j.l.Long.
Mark anonymous function methods as inlineable.
Add TraversableLike.filterImpl as ad-hoc inlineable methods.
Constant-fold (x === true) and the like.
Merge pull request #867 from sjrd/inline-list-foreach

More inlining that allows to inline List.filter
Fix #865: Inherit existing shell environment in external runners
wip
wip
wip