compiler: Re-implement lists as recursive types

This adds a basic recursive type system that allows the types of pairs
to reference a parent type. These references are implemented as explicit
references to the depth of the parent type - the pair itself is depth 1,
the type containing it is depth 2, etc. These type references can either
be handled by keeping an explicit type stack (as the valuetype package
does) or by careful use of unrolling (as used by PlanTypeCheck).

The depth references are awkward to handle in certain situations but
have the advantage of allowing our type structures to be completely
immutable. It also makes handling of recursion explicit which prevents
some unexpected infinite loops when handling types.

The type system attempts to be equirecursive - that is a type and its
unrolled form are equivalent except when printed. SatisfiesType will
follow recursive references until both sides have recursed at least
once. For the proper list case this works as well as the old system but
it runs in to difficultly distinguishing some similiar looking recursive
types - for example binary trees and lists. Fortunately this is
"conservative" in that it believes these types may satisfy each other
instead of definitely satisfying. This incurs a penalty for runtime
checks and reduces the number of errors caught at compile time but isn't
strictly incorrect.

Currently the type constructor allowing access to recursive types is
(Listof) which is the same as a hypothetical:

(Rec T (Pair <member-type> (U <empty-list> T)))

There are likely many bugs lurking in more complex types once those are
exposed to the user. Until user-defined recursive types are exposed and
are proven to work this will live in a branch as the complexity of
generalised recursive types is much greater than special casing just
proper lists.
compiler: Add (Rec) recursive type constructor

This allows Scheme programs to define arbitrary recursive types. The
type constructor's syntax is identical to the one defined by Typed
Racket.

This also adds unit tests for recursive type predicates now that they
can be defined.