compiler: Fix self recursive non-lambda definitions

The optimisation for self recursive lambdas was too eager. If it
detected any self-recursive definition it would disable the logic for
creating a recursive mutable but it wouldn't provide a self value to
replace it.

Fortunately most of the uses of non-lambda self-recursive definitions
aren't legal SCheme. However, if a lambda is embedded in another
expression as is the case for (delay) this bug can be triggered with
legal code.

Also re-enable the last (scheme lazy) test now that this is fixed.
compiler: Improve analyser and merge in to reducer

- Make the analyser iterate over expressions in reverse order which
  allows it to determine if a top-level define is used by the time it
  encounters it. This allows us to detect second-order unused defines
  and usage loops properly. It also allows us to completely drop unused
  lambdas after extracting their expressions without performing any
  additional work on them

- Remove the use of lazy functions and deferred symbol allocation in the
  planner. The new analyser should detect unsed defines well enough by
  itself

- Fix compiler exception on attempting to mutate an unused var and add a
  test.

- Remove (nearly) empty ReductionHelpers.scala
compiler: Rename Expression => Expr

The term "expression" is used frequently enough that the contraction
should be unambiguous. The saves us quite a bit of horizontal space in
some contexts
compiler: Comment clean up

Some comments have be revised our added but the bulk of the change is
merely re-wrapping comments at 120 columns and fixing Scaladoc style
compiler: Fix cell temp type in trampoline

The value being returned is actually of type %datum* but we were
constructing the temp value with type %listElement*. This is harmless as
we only use the type to determine if a value is GC managed at the moment
but it could conceivably cause problems later if more strict typing is
added
compiler: Clean up ps.Step naming

ps.Step used "Store" to refer to any step that stored a value in a
TempValue that did not fall in to one of the more specific types (e.g.
Unbox*). Additionally, the record-related steps had their verb at the
end instead of the step name which was inconsistent with the other
steps.

- Rename all steps creating a constant value to Create*

- Rename all steps loading a value from memory to Load*

- Rename the record-related steps to be consistent with the other steps
  both in the construction of their names and the verbs used
compiler: Add planner for cons, set-car!, set-cdr!

This generates code that's a bit bloated due to the need to check for
immutable pairs when mutating. Hopefully LLVM can eliminate it easily in
the cases where it's redundant
compiler: Mark GC and error signals as cold

This tells LLVM that _lliby_alloc_cells and _lliby_signal_error are not
called frequently and any code paths leading to them should also be
considered cold. This allows it to generate more efficient code at the
expense of losing support for LLVM 3.3. It also lets us get rid of the
GenLlvmExpect support as its no longer needed

Also mark _lliby_signal_error as noreturn as it unconditionally throws
an exception