vm: Slash a bunch of code from the o_build_list implementation.

This will make static list building a hair slower...but it allows cleaving
away a large block of code, as well as ensuring that aren't likely to be any
bugs in it. Considering the pain that I got from trying to fast path
subscript/subscript assign in the past, I'd MUCH rather go for this way.
Better generics to pave the way for maybe. Fixes #54.

The problem with the old system of generics is that they relied upon a 'self'
being the first argument to the function. For a long time, this worked fine
because the only functions that used generics had a particular templated type
they were working against. list::apply started with a list[T], hash::get
started with hash[K, V], etc.

The problem came when I wanted to add a new function 'some' to take in a given
type and return a 'maybe' containing that type.

function some[A](A value => maybe[A])

...This did not work in the old style. The new style of generics still works
with the old one. The major change internally is that the emitter keeps track
of the signatures seen for a particular function. In the case of:

list::append[A](list[A] self, A value)

consider: [1].append(10) which becomes

list[integer], integer

In both cases, the use of A is an integer, so everything is fine.

=====

I also touched up tree oo_call to have a guard against a true double eval so
that check_call_args can 'eval' it again and check the result without writing
code twice.
Emitter: get_storage never fails, so remove error checks. Oops.