First stage of typegen rewrite

This is a replacement for the Python typegen with a rewritten Scala
version. The goals of the rewrite are to:

- Reduce the number of languages used to implement Llambda

- Add unit tests to the typegen framework

- Introduce a more human-friendly cell definition format than the
  current JSON layout

- Remove Llamba-specific type definitions etc. from typegen itself and
  move it to the cell definition file

- Reuse and extend the existing llvmir framework instead of directly
  emitting strings

- Integration with sbt. This will hopefully allow at least the generated
  Scala files to be removed from source control without complicating the
  build process

- Support more advanced features such as field-level TBAA

This commit introduces a parser, unit tests and a new (parse-checked)
only cell definition file. No semantic validation or code generation is
performed yet
Add simple Vim plugin for celldef format

This uses the builtin C indenting along with a simple syntax file. It
merely highlights keywords in the correct context; no sort of validation
is performed.
Move Vim scripts to "vim" directory
Field type processing

This will resolve all of the possible field types, including their LLVM
IR type and C++ name. It checks for duplicate type names, undefined cell
types. unknown types, etc.

This resulted in some changes to the celldef format. In particular,
forward declarations are required before the use of any field type and
cell class bodies are now mandatory (as in C++)
Add cell class processing

This takes parsed cell types, resolves their fields and inheritence and
assigns type IDs and field TBAA nodes. This also contains changes and
fixes for other parts of typegen for issues that were encountered while
writing cell class processing.
Rename LlambdaApp -> CompilerApp

Now that we have separate projects under the io.llambda package the
compiler can't monopolize the name LlambdaApp. This is especially
important in the typegen-rewrite branch as typegen is about go get a
separate app.
Add simple command line to typegen

This currently only loads and processes the file but will be required
for when actual type file generation is supported
Ensure abstract cell classes have children

It doesn't make sense to have a abstract class as a leaf in the class
hierarchy - it can't be instantiated and it's not serving as the basis
for other types. Add new CheckChildlessAbstractCellClasses function to
be called after ProcessCellClasses to ensure they don't exist.
Add support for multiline comments

The celldef file format looks sufficently C like that it should probably
act like C whereever possible. Allow /* */-style block comments
Use ungreedy matching for multiline comments

The existing code would match the first #| in the file with the last |#.
This means all the data in between the first multiline comment and the
last would be parsed as a comment. Fix and tweak our unit test to catch
the issue.
Add generation of runtime predicates

This adds a concept of "writers" which are functions that take a list of
processed types and produce a map of filenames to content.
GenerateTypes will then write these to the filesystem once all the
writers complete.

This also adds a utility class called SourceBuilder which has helper
methods for generating C-like source. The only subclass right now is
CppBuilder but it's expect that a ScalaBuilder will be added that
produces properly formatted Scala.
Add generation of sizecheck.h

Except for the header the output is identical. Also remove an extra
newline generated at the end of predicates.cpp
Add FieldTypetoCpp

This will convert a FieldType instance to the correct C++ form. It can
either convert bare types (e.g. "std::int32_t") or in member/typedef
form ("std::int32_T somemember")
Add generation of declaretypes.h

This also changes the syntax of "root datum" to include an explicit
reference to the type ID field via the "typetag" keyword. The type tag
field isn't declared in declaretypes.h because it requires special
handling to build the enum.
Add CheckTypeTagField

This performs a series of sanity checks on our type tag field and it's
underlying type. This is to ensure we can safely generated a enum
containing all of the type ID values.
Add generation of typeid.h

This produces identical output to gen-types.py except for the generation
warning
Ensure cell classes only inherit from abstract

Inheriting a non-abstract class doesn't make sense as non-abstract
classes have a single static type ID. This means (parent? child) would
fail for any non-abstract child that inherits from a non-abstract
parent.
Fix deviations from cellTypes.json

git diff noticed these while generated the new C++ cell member includes
Add generation of *CellMembers.h

This finishes the runtime code generation logic. This generates the same
code as before with two differences:

- Instead of open coding our type check in the casters call
  ::isInstance()

- Use static_cast<> instead of reinterpret_cast<> in our casters
Add FieldTypeToLlvm

This is analogous to FieldTypeToCpp except it produces an
llvmir.FirstClassType. This will be required for Scala/LLVM IR
generation.