First attempt at better defaulting (#70). Lists seem to work.

To begin with, the emitter now has the idea of a 'floating' adjustment for
generics. Signatures from emitter's sig_stack_pos to the adjustment are
considered in use by the current generic call. This is an important and
necessary change, because it allows eval_build_list to look back to determine
what a generic should be.

Additionally, when a function is entered, it reserves that many generics so
that eval_build_list can access them right.

Consider this:
* list[integer] l = []

* list[list[integer]] l = []    l.append([])
  A is resolved as list[integer]. An empty list of integer is made.

* function k[A](list[A] l, A val) { l.append(val) }
  concretely known.

The generic adjust is a bit ugly, but there needs to be some way for list
evaluation to be able to access what a generic should really be.

The good parts:
* It seems that the 'try to fix it back up' part of type matching can go away
  as part of this. I've already removed the list case, with no issues.
* It is now possible to do 'list[integer] l = []'. This will be vital later on
  when declarations mandate assignments.

What's left:
* It needs to work for hashes and tuples.
* There's an opportunity to make signature building in emitter a bit better
  and simpler (for most cases, that is).
* Documentation needs to mention that [] is a list of any when there is no
  type information to use.
Finally! Better defaulting has landed. Fixes #70.

Better defaulting has been expanded to work on hashes and tuples. This took
way, way longer than I thought it would take. The basics of better defaulting
seem to work, but more nuanced things may be broke.

With this, the 'fixup' part of the emitter that tried to do post-repairs of
type information is now gone. Since type fixing is done during
list/hash/tuple building, there may be a slight decrease in memory use by
the sanity test from not building the wrong signature and ignoring it.

Anyway, this patch opens up some syntax things:
* list[list[any]] any_matrix = [[1]]
  This now works because any is given where '1' is wanted.

* any a = []
  This now works because 'a' gets an empty list of integers.

* list[integer] l = []
  Finally, lists can start off as being empty.

A test has been added to sanity.ly that checks a few different parts of
defaulting.

Beware: More clever things like generics and defaulting may break. At this
point, I'll fix any issues as I think of clever things to better test
defaulting.