The symtab now holds vars in a chain where top is the most recent.

Previously, variables were held in var_start and var_top. __main__ was
var_start and new variables were added to var_top. Searching for variables was
from globals to current vars.

The reason for this change has to do with class functions: If variables are
linked from newest to oldest, taking the top var away from the symtab's chain
of vars can be done by setting the symtab's var chain to the next entry in
itself (and fixing ->next). In the old method, it was much more difficult.

I did this because when writing basic user classes, I ran into a wall where I
needed to make the ::new function that contains other classes go out of scope.
However, I didn't have the var from before ::new was added. My options were:
* Start from __main__ and search for the var before ::new. Possibly expensive.
* Tell emitter about a class entry before the class entry (eww).
* ->prev for vars (NO!)
* Block entry gets the previous var (kinda weird too).

This solution seemed like it was the easiest one. Externally, there's no
change at all (I doubt this would even change speed at all).
First pass at user-defined classes. Careful, it's unstable.

Example:
    class Point(integer x, integer y) {}
    Point p = Point::new(1, 2)
    p.x = 10

Scala was a clear inspiration for user-defined class syntax. However, there
are some subtle differences:
* Point instances are obtained using Point::new instead of a new keyword.
* x and y are not constant by default. I don't intend to do that either.

Various parts of classes don't work. However, the intent is to improve classes
one part at a time, instead of trying to do everything at once. What has been
demoed above is most of what works.

What's left:
* Adding properties by declaring variables within the new of the class.
* Setting x/y within the new of a class won't update the properties. So if
  Point::new had a 'x = 11', that wouldn't be reflected in the built class.
* Functions within the class won't get added to the class when the class
  scope closes.
* Classes are not properly marked for potential circularity (if a property
  is an any, then there's a potential leak).
* Class == Class -should- work now, but may not.
* Creating new vars in the new of a class won't add them to output.
* Nested classes...will probably crash.
* No inheritance of any kind.

On the positive side, show works on class instances, which is rather neat.