compiler: Add more uses of vt.SchemeType

vt.CellValueType was previously used to represent Scheme types until it
became useful to explicitly exclude closure types (which aren't Scheme
visible). A few places were still using vt.CellValueType which makes
changing the definition of vt.SchemeType difficult.
Type system refactor

- Instead of having the compiler's type system be based strictly on the
  hierarchy of cell types to having a SchemeTypeAtom which represents a
  concrete cell type and a UnionType which represents a union of
  multiple types. Abstract cell types have a predefined UnionType object
  created but are otherwise normal unions.

- Have typegen create SchemeType instances for all the builtin cell
  types in the valuetype package. This replaces the use of cell types to
  represent Scheme types everywhere except special cases and low-level
  codegen.

- Define methods for adding, subtracting and testing if types satisfy
  each other that's used by both the planner and reducer. Add explicitly
  unit tests for these type operations

- Factor out type testing code in to PlanTypeCheck and have
  PlanTypePredicate become a simple wrapper around it

- Instead of the planner tracking possible cell types switch to just use
  a normal SchemeType and its union/subtraction/etc functions. This
  allows the merging of RecordValue, IntermediateCellValue, and
  IntrinsicCellValue in to a unified CellValue class

- Use PlanTypeCheck in intermediatevalue to perform any non-trival type
  checks (i.e. union types that don't exactly match a cell type or
  records)
compiler: Support custom type unions

This exposes the type union functionality introduced in the type system
refactor using the new (U) type constructor. This works exactly the same
as it does in Typed Racket.
stdlib: Expose <port> type

This was defined in (llambda nfi) but wasn't re-exported by (llambda
typed)
Implement  let:, let*:, letrec:, letrec*:

There are essentially copies of their respective versions in the stdlib.
Their forms are based off of Typed Racket with the exception that types
are always mandatory. This may change at a later time.

This also fixes a planner bug uncovered by letrec:that prevented typed
recursive mutables from compiling.