Version 0.13 of Lily. There are lots of changes here.

Most releases have been ~3 months, whereas this one took ~5.5 months. Here are
the major changes:

* pre-commit-hook.py is the main runner for all tests, both passing and
  failing. sanity.ly is dead, having been cut into many small passing tests.
  This has made Lily much more stable.

* It is now possible to catch exceptions raised from different interpreter
  operations. Also, they're *Error instead of Err* now. Exceptions are also
  raise-able from user code.

* It is now possible to create user-defined classes. Additionally, inheritance
  works (but it's a single-inheritance model). Some Ruby-isms have been
  imported for property access and signaling inheritance.

* The interpreter now understands generics and attempts to resolve them at
  vm-time. Parametric polymorphism, in all its glory, seems to fully and
  completely work. Generics were inspired by Scala, and seem close to Scala
  in terms of generic-related features.

* Internally, the lexer now understands entering and exiting files. This has
  allowed a lot of simplification of internals (Exceptions are now defined in
  code instead of hardcoded in). More importantly, this is a good chunk of
  what will be needed for importing later on.

* Enum classes, ala Rust, are now possible. With this, the interpreter now
  requires initial values on all declared variables as a means of removing
  nil from the user's perspective (intermediate values are still nil when
  first made though).
  I also took another page from Rust by allowing scoped variants.

* The interpreter now understands 'match' as a means of extracting variant
  information away from an enum class value. Unfortunately, match only works
  on enum class values for now (so it is not yet possible to use it like a
  switch, as in some more functional languages).

* It is now possible to create lambdas using '{|args...| ... }'. Currently,
  a lambda can only have one expression inside of it, a restriction that may
  be lifted in the future. Interestingly, lambdas can infer type information
  through generics (something that Scala has trouble with).

* The keyword 'define' is now used to create functions.

* Basic inheritance now works. The interpreter makes sure that property names
  won't clash, and that the values are laid out right. However, base values
  cannot yet be assigned to derived types (because there is no late binding).

* Finally, variable declaration is now done exclusively through var. Functions
  take the parameter name before the type (name: type), and var allows type
  info but does not require it (var name: type = value OR var name = value).

I don't intend to have such a long window between releases again.
