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
Improve desugaring to generate less temporary variables.
Emit ?: and , for If and Block in expression position.
Mark scala.Predef as an elidable module accessor.

Just because we know it's fine, and it appears so many times
in the output otherwise.
Update checksizes for the last 3 commits.
Merge pull request #868 from sjrd/less-temp-vars-in-desugar

Less temporary variables in desugaring
Mark more constructors as inlineable.

This typically flattens an entire inheritance chain of
constructors as a single constructor.
Merge pull request #871 from sjrd/inline-more-constructors

Mark more constructors as inlineable.
Add RefinedType to track types more accurately.

In particular, we track whether:
* the type is exact, i.e., the value is of that particular
  class, not any of its subclasses
* the type is nullable.

The former is mostly useful for determining the target of
a dynamic call: if the type is exact, we can perform the
lookup as if it were a static call, which always gives 1
target, which means more inlining is possible.
Merge pull request #873 from sjrd/refined-types

Add RefinedType to track types more accurately.
Fix #865: Inherit existing shell environment in external runners