Value rewriting, part 1: Lists have been fixed.

This branch was made for handling the rewrite of inner values so that they all
contain a proper value or set of values instead of flags+value union. This was
stuck in a branch because it's a VERY big change internally. It's going to be
a bit messy for a while too.

Reasons can be found in GH #15. Put simply, this allows more code reuse, and
values can be passed around much easier.

I won't change lily_vm_register until this is all said and done. That's a
cosmetic change, and I'd rather get to the meat of fixing things.

Changes:
* Lists now hold proper values (currently lily_vm_register *).
* generic_assignment added. This handles assigning two values of the same
  signature.
* List subscript and subscript assignment is now handled by calling
  generic_assignment. The list-related bits of both have been stripped out.
* lily_gc.c and lily_value.c updated for handling list elements. This change
  is fully working, and passes blastmaster.py fully (so no memory leaks/issues
  introduced).
Value rewriting, part 2: Fix part 1, and hashes.

It appears that part 1 only worked because I never did a 'make clean' to fix
lily_debug.c. It makes sense now that it was broken, since it does dump the
internals.

A few random things that were left behind by part 1 have been removed.

With this commit, hashes now have their key as one value, and the value as
another proper value. This has allowed hashes to take advantage of the new
generic_assignment call to handle assignments of anything to anything.

Subscript and subscript assignment are greatly improved, now that both hash
and list can use improved methods of setting values. Taking an axe to most of
the body of those two functions was -very- fun too.

Subscript assignment allows for nil values now. It never did before because
that was hard enough without that. No test yet though.

Hashes still don't ref their key, but will likely have to do so in the
future.

try_get_make_hash_value or whatever it was called has been replaced by
update_hash_key_value. This takes a key and value as registers, and does the
lookup, the new elem creation, and the assignment in one whack or raises
ErrNoMem. So that's a lot simpler and nicer.
Value rewriting, part 3: Objects now hold a 'register' in them.

This is annoying in some cases because checking that an object has a
valid value is now something like

object->inner_value->flags & whatever

But this has some benefits. One is that values can be unboxed from
objects and then act like normal. One such case is in o_jump_if,
where the contents of an object are unboxed, making o_jump_if work
the same regardless of if something is in an object or not.

With this commit, all of values in Lily that were holding
collections of flags/value/sig are now using inner values. This has
brought about a lot of nice things (like generic_assignment!)

Now, all that is left is to do some naming changes, and make things
take values instead of sig+value pairs and that sort stuff.
Value rewriting, part 4: Support for proper vals, some naming changes.

lily_value -> lily_raw_value
    A raw value is a value that doesn't have flags or a signature to go with
    it. These are no longer common, which is rather nice.

lily_vm_register -> lily_value
    Now, lily_value corresponds to a 'proper' value. A proper value is one
    that has a signature, flags, and a raw inner value.

Lots of functions were rewritten so they take a proper value instead of a
sig + raw value combo.

The gc still keeps a sig and raw value combo for gc_entry. This is because
there is little value in creating a proper value. For one, it would mean an
extra allocation. It can't save the proper value, because the proper value
may be a register that will change the sig+value (leaving the gc very, very
confused).

Added lily_deref_unknown_raw_val for destroying raw values.

This rewrite was necessary for a few reasons:
* Subscript and subscript assign of lists+hashes was atrocious. There were
  many, many bugs over time from forgotten parts here and there.
* It allowed making generic_assignment, which is a magic function that copies
  data from one proper value to another. This was used to make subscript and
  subscript assign saner and also more readable.
* This restricts ref/deref stuff in vm to fewer places, meaning fewer
  potential bugs.
* Proper values can be passed to more things, like deref and vm calls,
  resulting in fewer arguments to calls.
* I have a feeling that this will make foreign functions much, much easier.
  A list append would need to just expand list elements and call for
  generic_assignment without having to worry about type stuff.