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).