Represent ByteVectors using Vector[Short]

Vector[Int] is 32bit which is excessive. However, Vector[Byte] is signed
which makes it tricky to deal with as bytevectors are unsigned. Settle
on Vector[Short] which can represent all the values in a bytevector
without sign tricks
Fix typo in test name

Correct falso => false in the test name
Introduce the planner

The planner takes an expression tree and turns it in to a sequential,
single assignment set of plan steps. These plan steps are then passed to
codegen to be converted to LLVM IR. The introduction of the plan steps
allows some mid-level optimizations such as coalescing GC allocations or
removing redundant boxing that's not possible at the expression tree
level or at the LLVM level.
Remove VectorLike and tighten up typegen

The original plan was to implement both closures and record types using
VectorLike subclasses. However, this ran in to snags:

- Using VectorLike for closures forces them to always use BoxedDatum
  which is hard on the GC and loses type information easily

- User defined native types would be very useful passing structures to
  and from NFI. Scheme record types could easily be implemented as a
  special case of the user defined native types, or even as a macro.

Instead plan on implementing both closures and user-defined types
outside of the normal type system and provide type maps for the garbage
collector to use.

Removing VectorLike also gives an opportunity to simplify typegen a bit:

- Remove support for bitmask conditions. All type conditions are now
  equality conditions.

- Enforce that all concrete types are also final. This makes "abstract"
  basically a test for type ID being unset. Keep the "abstract" in the
  JSON just so it's clear to readers of the JSON which types are
  abstract. Code elsewhere already assumed this but it's nice that
  this is enforced at the typegen level.