Restructure Scheme libraries

This will allow the new unified library to use definitions across
libraries without creating include loops. The use case for this is using
(scheme case-lambda) to define variable argument procedures in (scheme
base).

- Fix LibraryLoader to properly set the package path when loading a new
  library. This allows library-relative includes to work as expected

- Create an interfaces/scheme directory containing just the (export)
  declarations for each R7RS defined library

- Place all of the stdlib definitions in a (llambda stdlib) library and
  re-export those through stub libraries using the appropriate file from
  the interfaces directory
stdlib: Implement optional fill for (make-*)

Make the fill argument for (make-list), (make-vector) and
(make-bytevector) optional by using (case-lambda) in the stdlib. This
required moving the (case-lambda) definition much earlier in stdlib.scm
so it could be used by the rest of the base library.

It's been manually confirmed that direct invocations of the new
procedures will be properly reduced to direct native function calls at
-O 2. The code generated for the generalized (case-lambda) is suboptimal
but hopefully it won't be invoked too frequently.

(make-list) and (make-vector) default fill with unit values while
(make-bytevector) fill with zeros. R7RS allows us to fill with anything
if the fill is unspecified but those values seem reasonably sane.
compiler: Merge identical steps

- Add Step.renamed that will rename all temporary values (except the
  world pointer) to new values. This seemed cleaner than cloning or
  no-op casting TempValue

- Add MergeableStep trait to indicate steps that can be safely merged.
  This is the majority of them but the most heavy weight ones (i.e.
  Invoke) aren't candidates

- Add conniver.MergeIdenticalSteps that merges and renames Steps based
  on the above infrastructure
compiler: Optimise GC rooting

Previously every GC-managed TempValue that passed through a GC barrier
was assigned a unique GC slot. This has a number of problems:

- TempValues created by casts will have identical pointer values and
  only one of them need to be saved

- Many TempValues have non-overlapping lifetimes and can therefore share
  the same slot space

Instead of tracking TempValues the GC code is concerned with "pointer
identities".  Normally every new TempValue is assigned a unique pointer
identity but casts will cause the new TempValue to point to the pointer
identity of its original. This solves the problem of identical pointers
being saved to the shadow stack

The overlapping lifetime issue is a bit trickier to solve. Firstly, we
now flush all of our unsaved roots to the shadow stack before entering a
conditional branch. This prevents branches from assigning new slots to
the same identity in their respective branches. Then, we keep track of
the next unallocated slot and the currently rooted slots. Any allocated
slot that isn't rooted is free to be reassigned to a newly rooting slot.

We have logic to prefer transferring slots that have just derooted to a
newly rooting slot. This means we can avoid nulling out the slot and can
just overwrite it directly.
compiler: Don't GC manage phi of constant cells

If both sides of a phi come from constant cells the resulting phi'ed
value doesn't need to be GC managed either. This reduces GC overhead
slightly in those cases.
compiler: Better tracking of which values to GC

When GC support was initially added to codegen TempValue had an
"isGcManaged" flag. Every user of TempValue needed to manually annotate
each new TempValue as either managed or unmanaged. This was nearly
manageable but we want to start considering all preconstructed values as
GC unmanaged which pushed the complexity over the edge

- Add TempValue constructors to each class of temporary value. This
  doesn't immediately contribute to a more strongly typed Step but it
  could become useful later.

- Convert nearly all users to the new TempValue constructors

- Have typegen give preconstructed cells the supertype of
  PreconstructedCellType

- Make ValueType consider preconstructed cells non-GC managed. This is
  the only (intentional) functional change which allows us to avoid
  rooting cell types we know can't have runtime allocated instances.
compiler: Allow inlining trivial conditionals

Allow inlining if the inlined value is simply a conditional on an
inlineable application returning two trivial values. This occurs in the
Life example program in R7RS.