Refactor Uncurry for future delambdafy work.
Refactors Uncurry's transform function to call a generalized
"createMethod" in anticipation of the work to be put into Uncurry for
deferring delambdafication.
Adds a setting to delay delambdafication. If set then uncurry lifts
the body of a lambda into a local def. Tests are included to show the
different tree shapes.
Refactor Erasure for delambdafication.
This commit is purely a refactor. It pulls code needed to adapt a tree
of one type into a tree of another type (by casting, boxing, coercing,
etc) out of Erasure and into common locations that will be usable
from the Delambdafy phase.
Flesh out the Delambdafy phase.

This commit puts a real body on the Delambdafy phase.

 From a lambda, Delambdafy will create
 1) a static forwarder at the top level of the class that contained
      the lambda
 2) a new top level class that
      a) has fields and a constructor taking the captured environment
(including possbily the "this" reference)
      b) an apply method that calls the static forwarder
      c) if needed a bridge method for the apply method
 3) an instantiation of the newly created class which replaces the
   lambda

A few basic tests are included to verify that it works as expected.
Further commits will have additional tests.
Make GenASM not eliminate loadmodule on static methods.
During development of delayed delambdafy there was a problem where
GenASM would eliminate a loadmodule for all methods defined within that
module even if those methods were static. The result would be broken
byte code that failed verification. This commit fixes that and adds a
test.
Make specialization aware of anonymous functions.
During development of late delmabdafying there was a problem where
specialization would undo some of the work done in uncurry if the body
of the lambda had a constant type. That would result in a compiler crash
as when the delambdafy phase got a tree shape it didn't understand.
This commit has a fix and a test.
Create test variants where delambdafication alters signatures.
This commit includes several tests where there's a variation in
signatures between inline delambdafication and method based
delambdafication.
Force several tests to run using inline delambdafication.
The differences when running with method based delambdafication aren't
important enough yet to create specialized versions that use method
based delambdafication.
Mark tests that fail under deferred delambdafication.
These tests represent a big TODO. We currently have a bit of logic that
attempts to protect the compiler from generating byte code that uses
'this' during a call to a super constructor. There are two problems with
that code. First, it happens early before delambdafication has a chance
to simplify the code. Second, it's incomplete and it's easy to write
code that sneaks past the verification but produces broken byte code.
The conclusion from the team is that that logic needs to be pushed into
a much later phase, possibly after going to the ICode/ASM IR. But that
change is outside the scope of this work so for now these tests are
simply forced to run only with inline delambdafication.