compiler: Move the list reversal

It seems cleaner to hide the reversal of the accumulator list in to the
function itself
compiler: Known procedure comment cleanups

- trampofile => trampoline

- adapated => adapted

- Re-wrap at 120 columns

- Grammar fixes
compiler: Add functional test for large programs

The planner and conniver contain tail recursive style code that's not
being having tail call optimization applied. The result is a compiler
stack overflow for even moderately sized procedures.
compiler: Make DisposeValues mostly tail recursive

DisposeValues will now only use non-recursive calls for entering nesting
steps instead of on every plan step. This greatly reduces its stack
usage and as a result increases the maximum procedure complexity it can
handle.

Also rework some comments and variable names to be more clear
compiler: Rewrite PlanCellAllocations

- Use the reverse steps with accumulator pattern that DisposeValues
  uses. This greatly simplifies the code and makes us properly tail
  recursive. One side effect is we'll place our allocation directly
  after the last GC barrier instead of directly before the first
  consumer.  This should be a noop except for cache effects.

- Don't create a GC barrier for nested steps (such as conditional
  branches) that don't contain cell consumers or allocations. This
  should give more opportunities for merging allocations together and
  therefore reduce GC overhead.
compiler: Optimize invoking captured procedures

Capturing a procedure in a closure and later restoring it was losing the
signature information. As a result the procedure's trampoline was always
invoked. Add IntermediateValue.restoreFromClosure to allow intermediate
values to do value-specific restoring. Override it in KnownProcedure to
preserve the procoedure signature.
compiler: Typo fix

optimizatins => optimizations