Replace StepBuffer with PlanWriter

StepBuffer was just a ListBuffer of ps.Steps. This was fine if we're
only generating a single function but falls apart quickly otherwise.

PlanWriter contains a "step" member which is analogous to the old
StepBuffer. Additionally, it contains a mutable map which allows any
method that can output steps to define new functions. This is required
because IntermediateValue needs to generate stub trampolines to for
procedure boxing deep inside its implementation.
Add ps.StorePair{Car, Cdr}

This will be required for boxing procedures as the generated trampolines
need to walk the rest arg list. However, replacing (car) and (cdr) with
these steps allows LLVM to optimize them very aggressively effectively
for free.

- Propagate report names from the expression tree to our intermediate
  values. This allows us to detect when we're applying report procedures

- Add reportproc.ReportProcPlanner trait and have PlanExpression call in
  to it. This allows objects to hook in to PlanExpression's application
  logic and replace stdlib calls with plan steps

- Only enable replacement at optimization levels > -O 1. Otherwise it's
  hard to test the stdlib procedures without going through some awkward
  value laundering to hide them from the planner

- Add ps.StorePair{Car, Cdr} and implement codegen for them

- Add CadrProcPlanner that replaces applications of (car) and (cdr) with
  StorePair{Car, Cdr} steps

Switch report proc planning only at > -O1

Unconditionally replacing report proc stdlib calls makes it difficult to
test the stdlib implementation. Instead only switch on report proc
planning at O levels above 1. This will allow us to run our unit tests
at both O2 and O1 to see what breaks. Unfortunately our unit tests
require O2 to de-lambdaify expanded (begin) macros.
Fix typo'ed filename

The class was already correct so it just needs to be renamed
Properly use allocIndex while boxing

The index of 0 was hardcoded. Currently all indexes are 0 until a Cons
optimization pass is added. However, this will break subtley once
non-zero indexes are introduced.
Adjust NativeSignatureToIr for the new closure arg

Previously the entire boxed procedure was being passed to functions with
closures. This was recently changed to be a void*/i8* to a custom type
mapped type. However, NativeSignatureToIr was still converting a clsoure
arg to procedure*
Fix stupid "arguemnts" typo in GenPlanStep
Support for first-class procedures

This adds runtime boxing and unboxing of procedures. If a procedures
signature doesn't match the generic BoxedProcedureSignature it will have
a trampoline built at runtime to adapt the signature.

Currently closures and user-defined procedures are not supported. Only
NFI functions can be boxed and unboxed. This provides much of the
framework for user-defined procedures, however.