Prep work for closures and records

The initial plan was to represent closures and records using a structure
similar to vectors. Unfortunately that requires all data to be
explicitly boxed. Also, being able to specify native types in records
would be useful for NFI. Instead move to user defined types using type
maps

- Add BoxedRecordLike. This is just an opaque container for a record
  class ID and record data. The record class ID will index a type map
  that will indicate where all the boxed values are for the garbage
  collector to follow

- Make BoxedProcedure a subclass of BoxedRecordLike

- Change the BoxedProcedure entry point to take a void* pointer to the
  record data instead of the boxed procedure cons itself. This can
  potentially save a dereference on the procedure side if we already
  have the record data pointer loaded.

- Rename the "self" argument to the "closure" argument in our signature
  code to reflect the above change
Simplify VarRef matching in PlanExpression

Since commit 9b4d6f3 isn't not possible for et.VarRef to contain
anything exceot a StorageLocation. Remove code in PlanExpression to
verify it's receiving a StorageLocation and let the type system handle
it.
Clean up temporary test executables

I was under the impression that File.createTempFile implied
deleteOnExit. This was clearly not the case. Additionally, we should try
to delete the test exectuable as soon as we're finished using it anyway.

Both call deleteOnExit() and wrap the test execution in a try/finally
that will delete the executuable. This both prevents garbage from
accumulating and likely reduces disk writes due to most of the tests
being deleted before they have a chance to be scheduled for write.
Make et.Expression.map source location-safe

This makes et.Expression.map implementations preserve the source
location from the original expression. This makes location reporting in
the planner usable when the optimizer is enabled.
Add "compile" mode to the Repl

- Add "compile" mode and make it the default mode. This compiles each
  entered expression as a standalone program. This is identical to what
  the old Llispy REPL did

- Rename :body to :expr. I don't intended to add REPL mode for other
  types of expressions so :expr is a clearer name

- Clean up the parse error exception to be less verbose by omitting the
  exception's class name
Add ValueNotApplicableException

This converts the InternalCompilerError in the Planner to a full fledged
SemanticException.

Originally this was intended to be caught in the frontend and anything
that reached what was at the time part of codegen would be an ICE.
However, this code has been moved to the planner and only it has enough
type information to determine if something is definitely not applicable.
This is closely analogous to ImpossibleTypeConversionException which is
also caught in the planner.

Making this a LocatedSemanticException also gives us proper source
location reporting for free.
Remove debug println()

This was used to unravel the madness of relocating exceptions and was
never removed
Add (typeless-boxed) to (llambda test-util)

This is a macro that expands to the (car (cons <foo> #f)) pattern to box
a value and erase its type information. In addition to making the intent
of the unit tests more clear this also allows for easy replacement once
our optimizer is clever enough to optimize away tricks like that.
Update to Scopt 3.2.0

This has some minor updates for how help works that are useful for us.
Add IntermediateValue.toInvokableProcedure

This provides a hook for boxed procedures to eventually unbox themselves
automatically when they are applied. The actual unboxing logic is
unimplemented so this has no functional changes.
Add test for procedure?

It's currently not possible to box procedures to his merely confirms
that it returns false for non-procedure.