Exceptions, round 1: Added properties (unused), basic try, basic catch.

If I do exceptions all at once, I'm -very- likely to miss something. So I'll do
them piecemeal.

* The notion of properties now exists. Each exception will have a stack trace,
  as well as an error message. Properties will also be inherited, which is why
  the division by zero error doesn't have them but the future-base Exception
  does.
* This adds the try keyword and the except keyword. I've only tested multi-line
  try+except blocks (I expect single-line ones may fail now). The basic chaining
  from the try+except blocks to the next except block -seems- to be working.
* The vm has two new opcodes: o_add_try, and o_except. However, the vm does not
  actually use o_except blocks (exception processing loops over try entries to
  find one with a proper class entry). In theory, this model should support
  nested try blocks (totally haven't tried doing this yet though).
* I've added exception_test.ly at the src/ level. This will stay until
  exceptions have been ironed out, and be added to as exceptions become more
  complete.

Exceptions are pretty rough right now, but they'll slowly get better.
Exceptions, round 2: Convert Err* to *Error.

I did a general sweep through everything to convert error names from their old
names to new more Pythonic-names. I originally named them as Err* because I
thought that would be a fun way to differ Lily from other languages.

I also made number instead of double, object instead of any, and string instead
of str. So...I'm starting to think that "making clever names for stuff" is less
and less of a good idea. The simpler, the easier to remember.
Exceptions, round 3: Handle other exceptions now.

All errors that can be raised at vm time are now initialized in classes, and
handled during error catching. The exception test now checks for RangeError
which is raised when a subscript is out of range.

Also fix a wildly incorrect comment over symtab's lily_class_by_name.

Did an adjustment in parser so that blank except entries work in multi-line
blocks.
Exceptions, round 4: Add parents to classes, make lily_seed_symtab more sane.

For the first one, the parent of a class is given as a string. This is
important, because future classes will need to do this. For example, a mysql
function needs to a particular class, it has no guarantee of what ID it will
have. So it will need to use a string for identity. Or...something.

For the second, class init now has a second pass where parents are
initialized to a non-NULL value. This is so that lily_class_by_id is not
called when all classes have not been filled in (and where there may be empty
ones!)

This is a step toward checking that 'except' gets something that can, you
know, actually BE raised. Also, inheritance!
Today's lesson: Check commits before forcing rebase.

...Because there might be bits about stashed changes inside, completely
breaking the code. Whoops.
Exceptions, round 5: Inheritance checks!

'except' now verifies that the given class derives from Exception, which is
pretty important. Additionally, the vm checks for inheritance when processing
exceptions. This means that if the 'except' class given is more general than
the raised exception, it works anyway. This pattern is used sometimes to catch
any exception and log it.

Also, fix classes to actually init parents (the line that set classes pos just
needed to be moved up. Small oopsie there).
Exceptions, round 6: Pop a try at the end of it.

If a 'try' block does not raise an exception, then the catch entry added needs
to be removed. If it is not, the vm will try to use it on the next exception
(with a near-certain crash).

This adds an instruction called o_pop_try that just pops a try entry when
there is no exception raised.
Exceptions, round 7: Unwind stack when catching exceptions. New tests.

This one took a bit of time to figure out. However, it seems to work correctly
except that it doesn't reclaim the registers (it also needs to adjust the
current number of registers used). I'll fix that later though.

Added two tests: One catches an exception raised in a different function, the
other does a nested exception test.
Exceptions, round 8: Create a proper exception object, show it.

The parser now understands that adding 'as <name>' to the end of an 'except'
means that an exception object should be made and put into that var. So, for
example, 'except ValueError as V' would put the contents of the exception into
var V.

The vm will only create an exception object if 'as <name>' is specified. This
is an optimization: In cases where the user -just- wants to know that a
particular exception has been raised, this avoids creating a
somewhat-expensive exception object that will just get ignored.

The exception object created is fairly useless...but it can be passed to show
to prove that the contents are correct.

If the vm is creating a traceback object and runs out of memory, the following
NoMemoryError that gets raised is uncatchable. This is done intentionally to
keep the interpreter from doing an infinite loop trying to build traceback if
it's out of memory (because aft WILL test that).

Added a test that checks the new 'as <name>' syntax and shows the created
type.
Exceptions, round 9: Various fixes (aft, debug, stack unwind).

debug:  Add a D_INT_VAL for o_except. This is a fix for the last commit which
        added a 0/1 so the vm knows if it has to make an exception object.
aft:    In vm teardown, move catch_chain to the beginning
unwind: Use a local var to hold the new function_stack_pos as it winds down.
        Otherwise, function_stack_pos will be over-adjusted if two catch
        entries have the same depth. This causes a crash.
        At the end, fix vm's catch_chain backward. This prevents old catch
        entries from being selected for a new pass (this is just wrong).
Exceptions, round 10: NoMemoryError::new finally works!

With this commit, it is now possible to access functions of a particular class
by using '::'. If this is done, then the first argument will need to be passed
to the function obtained (since .x() adds the first argument).

Example:
	"abc".htmlencode()
is also
	string::htmlencode("abc")

This could be useful in future situations where one would like to pass a
certain function of a class without requiring an instance of it. Or maybe it
will just be a side-effect of allowing static calls to ::new.

Anyway, this sets things up to allow for creating other errors in the future,
and later raising those errors.
Exceptions, round 11: RangeError -> IndexError, drop NoValueError.

The maybe class would have made NoValueError obsolete anyway. The other
conversion was done because Python has IndexError instead of RangeError for
invalid indexes.
Exceptions: == and != for exceptions work, plus a ::new for new exceptions.

A new exception instance can now be created like this:

DivisionByZeroError::new(message)

This works for all errors that can be caught, aside from Exception since that
is a base class. Additionally, comparison is now supported by instance values.

No raise just yet though...
Exceptions: 'raise' and a test for it.

The interpreter now understands a 'raise' keyword. This keyword expects a
value that derives from Exception. A test has been added to exception_test.ly
to ensure that the exception can be caught properly.
Exceptions: Pop try blocks for continue, break, return.

This fixes a previous issue where one of the above inside a try block would
cause the block to never be unregistered by the vm. So the next catch could
possibly jump back into a block that the vm is no longer within.

Added BLOCK_TRY_EXCEPT to emitter. When the emitter reaches an except block,
BLOCK_TRY becomes BLOCK_TRY_EXCEPT. This also helps the emitter determine how
many try blocks that need to be popped (if any).