Promote Unspecific to an AST type

Use the MIT scheme/Llispy style of representing unspecific using
"#!unspecific". This also simplifies et.Conditional a bit by making the
false expr a simple Expression instead of an Option. In the case of no
false branch it will just contain et.Literal(ast.UnspecificValue)
Comment fixes
Create llambda.frontend package

- Separate our the llambda core (mostly data structures + REPL) from the
  nearly functional llambda frontend

- Mark many classes in the frontend as package private. Unfortunately
  the REPL needs to do some unusual things so it access can't be as
  restrictive as I'd like

- Move tests in to the same package as the code they're testing. This
  allows for them to access the newly package private classes
Rework body parsing and the expression tree

- Add a first-class et.Let type that defines a variable for a set of
  body expressions. This replaces Procedure.bindings and should let the
  simplifier more easily inline lambdas by converting them to Lets if
  needed

- Explicitly express mutation of an existing variable using et.MutateVar

- Rename many of the other ExpressionTree classes based on lambda
  calculus and Haskell's Core

- Rename ExtractBody to ExtractModuleBody to more closely reflect that
  it's intended for use in ExtractProgram and ExtractLibrary

- Add ExtractModuleBody.parseDefine that understands the various forms
  of (define). Make ExtractModuleBody.apply and createLambda both use
  this helper to parse their definition types

- Track the original unqualified source names of StorageLocations for
  diagnostic purposes

- Implement mutually recursive lambda definitions and add a unit test
Define (begin), (let), (and), (or) and (when)

These are simple macros that can be defined purely in terms of primitive
expressions we already support. Their definitions are taken verbatim
from R7RS with the exception of tagged (let) which requires (letrec)
Update to Scala 2.10.2
Add CMakeLists.txt for runtime library

This currently only builds a single file (fatal.cpp) for testing
purposes. Everything seems to work as expected on OS X 10.9
Change nfi.Bool to nfi.Bool32

nfi.Bool was previously defined as i1. Predicates are expressed in LLVM
IR as i8 but the x86-64 ABI packs it in an i32. We should be using the
i32 version when describing function signatures.

At the same time add an alias from "bool" => nfi.Bool32 in case we port
to an ABI that uses a different sized bool