compiler: Out-of-line type checking

Support planning any type check out-of-line if doing an inline check is
determined not to be obviously beneficial. We then depend on LLVM to
re-inline the type checks that are cheaper than functional calls on the
target platform. This has two main motivations:

- We're supporting more complex types such as arbitrarily tested typed
  pairs. Always planning internally placed type checks inline can be
  quite wasteful and bloat our output

- Recursively defined types such as proper lists will need to tail call
  the type predicate procedure from within itself. This isn't
  implemented yet but becomes much easier after this change

To accomplish this:

- Introduce a new planner.BoxedValue that wraps a TempValue and its
  current CellType. Move the functionality of IntermediateValueHelpers's
  cellTempToSupertype to BoxedValue.castToCellTempValue. This doesn't
  change behaviour but lets intermediatevalue and typecheck interact
  more easily

- Introduce IntermediateValue.toBoxedValue that will return a boxed
  value of any type for a given IntermediateValue. For CellValue this
  just returns its current representation; for other values this returns
  the preferred boxed representation for the value. Most non-CellValue
  types already had an analogous function that just had to be tweaked to
  match the toBoxedValue() signature

- Move the management of known type predicate functions to typecheck.
  This is mostly so typecheck can properly plan recursive type
  predicates in the future

- Move the decision to inline a type predicate from
  KnownTypePredicateProc to typecheck.PlanTypeCheck. This means all type
  checks are eligible for out-of-line planning, including internal
  checks performed by PlanTypeCheck itself
compiler: Remove StaticTypePredicates test suite

The file is misnamed and duplicate entirely by ListProcSuite.scala
compiler: Initial proper list type support

- Add vt.ProperListType which represents a simple proper list

- Extend vt.SatisfiesType to know about proper lists and their
  relationship with pairs/empty lists

- Extend typecheck.PlanTypeCheck to be able to the plan recursive types
  by performing a recursive tail call.

- Add (Listof) type constructor as used in Typed Racket

- Replace (list?) with (define-predicate list? (Listof <any>))
compiler: Remove vt.CBool

Get rid of vt.CBool/vt.BoolLikeType and have vt.Predicate be the only
boolean native type.

The 8bit CBool was initially the only boolean type based on the
observation that Clang stores C++ bools as i8s in local variables and
structs. However, on closer inspection Clang will use i1 for bool
function arguments and returns.  Presumably the reason boolean variables
have i8 type is to satisfy the C++ requirement that every variable has
a unique address and pointers can only address bytes. Changing i8 to i1
manually in Clang's LLVM IR output doesn't generate different assembly
on x86-64 for trivial programs.

In addition to simplifying the compiler code this generates better
assembler. Truncating an i8 to an i1 will explicitly checks that the
lower bit is set while using an i1 lets the compiler know the value can
only be 1 or 0. The trunc/zexting between CBool and Predicate actually
prevented tail recursion in the first pass of the proper list type
implementation due to extra x86 instructions being generated.
compiler: Use explicit tail call in typecheck

Pass the "tail" modifier to LLVM when we call ourselves recursively in a
type check. This provides a strong hint to LLVM that don't want
unbounded stack usage when checking a recursive type. This should really
be "musttail" but that's not supported by LLVM 3.4.
compiler: Remove empty arg list hack in planner

Previously there was a ps.BuildProperList plan step that would take a
world pointer and build a proper list in codegen. There was a hack in
PlanInvokeApply to avoid creating BuildProperList for empty lists to
prevent a false worldPtr usage

Now we explicitly plan out proper list construction which means we can
directly call ValuesToProperList and it will do the right thing.