runtime: Remove stranded comment

This was reference to the allocNext/allocEnd pointers which are in
Heap.h now.
stdlib: Remove lliby_list

This is more naturally implemented as a procedure returning its rest
argument. The generated code is identical
runtime: Introduce ProperList::emplaceValues()

This allocates the space for both the pair cells and values cells at the
same time. It then invokes the cell constructor using the values in the
passed container. This has a number of benefits over pre-constructing
the values and passing them to ProperList::create():

- Less boilerplate code in the callers to deal with range allocations

- The entire list can be allocated at once. This removes the overhead of
  an allocation and lets us avoid GC rooting our boxed values

- The pairs and values are laid out sequentially in memory which has
  better cache locality
Add literal types for symbols

This allows symbols to be used in a similar fashion to enums in other
languages while still being type-safe. This doesn't significantly
improve the performance of enum-like symbol usage but it makes it
possible to optimise later.

- Rename Constant{Value,Boolean}Type => Literal{Value,Boolean}Type. This
  more accurately reflects their purpose

- Add a ConstantSymbolType. The type system only required additional
  logic in NameForType; the general LiteralValueType infrastructure
  already handled type comparisons and arithmetic.

- Add a new TypeConstructor called LiteralTypeConstructor. Any usage of
  quoted datums will trigger the LiteralTypeConstructor. Besides
  allowing symbol types this also allows '() as an alias for
  <empty-list>

- Add _lliby_symbol_is_eqv core runtime function. This works the same as
  _lliby_is_eqv except it's marginally more efficient as it can skip
  type checking.

- Teach PlanTypeCheck to use _lliby_symbol_is_eqv for checking
  LiteralSymbolType

- Change EquivalenceProcPlanner to use _lliby_symbol_is_eqv when both
  values are known to be symbols.
compiler: Limit the size of (make-vector)'s type

The report procedure planner for (make-vector) will generate a
SpecificVectorType for the created vector if the length argument is
known. For very large vectors this could result in a type with hundreds
of thousands of elements. When performing type arithmetic etc. on those
types the compiler could effectively livelock or abort due to GC
overhead.

Instead limit the SpecificVectorType size to 1024 in (make-vector) and
fall back to UniformVectorType if that limit is exceeded.
runtime: Speed up vector (equal?) by 35%

We were using elementAt() when comparing vector contents even though the
vector length is explicitly validated previously. Clang doesn't elide
the range check in this case, possibly due to the side effects isEqual()
could have.

Instead, use elements()[i] which doesn't have any range checking. This
results in 35% reduction in runtime when comparing large vectors on
x86-64