ast: Kick out saved_trees in favor of a linked list of save entries.

I'm pretty sure the old way had a minor bug in that it would have been
possible for an entered tree to have an incorrect parent. I don't think this
would have caused any major problems though.

This makes tree saving seem less like a hack. It also makes trying to dump
ast easier...at least, that's the hope. :)
vm: Finally implement a garbage collector. Fixes GH #11.

circular (SIG_MAYBE_CIRCULAR), then the value needs to have a gc entry created
for it. Any request to add a gc_entry may trigger the gc if the gc has more
than a set threshold of items listed. Some types, like list[integer] do not
have a gc entry, because they can't become circular. Additionally, symtab can
still deref values to destroy them, even if they have a gc entry attached.

The garbage collector works in four phases:
1: Go to each in-use register, and use the gc_marker call that is associated
   with the class of the register's value. This call decends into the value
   and marks everything seen by setting the gc entry's last_pass.
2: Start collecting everything in values that have not been seen. Do not
   collect the values themselves, because other values being collected may
   refer to them (we are dealing with circular refs after all!)
3: Go to each _unused_ register, and check if it has a value that has a gc
   entry. If it does, mark that register as nil. This prevents the vm's
   prep_registers from trying to deref the value later.
4: Finally, free the leftover values. This is safe now that the values are no
   longer referred to by anything else. This also sorts the entries visited
   into unused entries and used entries. A recount of the amount of living
   values is also done.

When the vm closes, it now calls the gc but says it has no registers. This
forces the vm to clear everything from the gc, which is good. Unfortunately,
vm and symtab teardown is kind of weird now.

Because the gc can fire from any request for a gc entry creation, it's now
very important to think of value creation as 'transactional'. o_build_list has
a good example of this: The new list is assigned over the old one before
building the values now, instead of after.

I hereby declare circle_buster and marking things as SYM_IS_CIRCULAR as the
worst idea I have ever added to Lily (#2 would be refcounting signatures).
This decision made lists FAR worse to handle.

Note: As of now, hashes are not marked. This will be done after static hashes
      can be created ([a -> b, c -> d, ...]).

Goodbye circle_buster.