Create LICENSE
Split the project into two modules called "blocks" and "math"
reworked sbt file structure in order to facilitate sbt-pack
Fixed bug regarding empty lines after math blocks.

What was happening was an empty line at the end of a math block was
being treated as a successful equation and an extra \\ linebreak
was added.  This fix adds two tests for the behavior and fixes
the bug by filtering on only lines that have contents.
Performance upgrade for 1b9ff78a

Sometimes I forget this project isn't in hackathon mode :)
Nested sublists work correctly.

Before, you would write your sublists like:

    |list
      |item Foo
      |item
        |list
          |item Bar

But now it's just

    |list
        |item Foo
        |list
            |item Bar

Turns out this is actually the way you are supposed to do it...
Made all of the Blocks objects instead of classes.

There was no real reason for them to be classes instead of
singleton objects.
Finished and tested the |italic and |bold blocks

They use \textbf and \textit for the environment wrapping
which is probably not ideal, but until I find something else...
cleaned up old code
Blocks have access to their line number.

At parsing time, blocks are given the line number that they were
created from.
added better exception handling and messages
Implemented multi-block mode.

Many blocks will only have a single child.  When this is the case
it is a waste of space to have a single line for the parent.

With this change, it is possible to transform

    |list
        |item
            |math a + b = c
        |item
            |math a^2 + b^2 = c^2

into

    |list
        |item/math a + b = c
        |item/math a^2 + b^2 = c^2

Much better.
Started work on a new math parser.

This parser is different in a few key areas.
1. It parses to an intermediate representation.
   This IR is made up of a sealed trait and some case classes.
   The point being that it's way easier to test this way, and
   we decouple code generation from parsing.
2. MOTHER FUCKING PACKRAT PARSERS
   By mixing in the PackratParsers trait and reworking the structure
   of the parsing code in general, we are able to use packrat parsers
   which memoize the parsing internally leading to faster parse times
   and more importantly, enabling us to write left-recursive parsers.
Broke up chunks and fixed super and subscripts

Chunks used to just be series of characters that we didn't really
deal with in any other places.  Now they are parsed into different
classifications (though they all end up as a Chunk).

numericChunk: /-?[0-9.]+/
    Anything that could look like a number.
characterChunk: /[a-zA-Z]+/
    Anything that looks like text / variables.
symbolicChunk: /[^()!:;,/_\ ^a-zA-Z0-9]+/
    Anything that isn't being used by our language and
    isn't a numeric or character chunk.

This distinction is useful because it means that
  a+b/c
gets parsed as 'a' + ('b'/'c') instead of ('a'+'b')/'c'

Sub/super Scripts were getting really confused because they would
always interpret
  a_1 / 2
as
  a_(1/2)
no matter what the presidense of the two operators is.

This change makes it so that a sub/super script can not contain
an un-parenthated division or sub/super script as the argument.
Added the code-gen end for math mode

The code generation stage for math mode is quite simple and
it merely recursively travels down the AST handing a StringBuilder
off to each successive node to append to.

Also in this commit are tests for the code-gen stage.
started implementation of macro and super macros for the code generator
added tests and finished super macro implementation
Way too much in this commit.  Sorry.

So in this commit (sorry) I made the following changes:
* Removed old math parser and tests
* Wired up the new path parser and code generator
* Added comments
* Fixed how we do alignment
changed the name of the multi-module project and the name of the compiled binary
Create README.md