Emitter: Call evaluating has been put into a new function.

Call evaluation has become complex enough that repeating it in normal collect
and vararg collect is no longer feasible.
Generics: Generic entries now scope in/out appropriately.

function f[A](A val1) {
    # A is available, but nothing more.
    function g[A, B](A val1, B val2) {
        # A and B are available, nothing more.
    }
    # B no longer available
}
Now A is no longer visible.

If functions can nest within each other, then generics should be able to scope
in/out as well. I haven't tested how classes deal with generics yet (probably
a crash or just ignoring them), but I'll make classes work with generics soon.
Generics: Only call argument checking should match generics.

Previously, things like assign and return would use type_matchup to both fix
types. But...type_matchup also included code to unbox a template and do
template matching. This is bad, because it means that things like trying to
assign to a generic value don't work.

Now, only call evaluating tries to work with generics (because that's the only
proper time to figure out generics). Call evaluating now uses
generic_type_matchup which does type matching as well as the generic stuff.
type_matchup no longer does generic stuff, naturally.

Also, trying to fixup static lists/hashes/tuples has been thrown into a
function within type_matchup. I...sort of hope to eventually get rid of that,
but for now putting it away from everything else (and only attempting to call
it when the tree type is right) works.

With this commit, generic variables can now be properly assigned to within a
generic call.
debug: Make show print out the generics of a function if there are any.

This prints show as 'function[A](A)' now instead of just 'function (A)'. I
like the new way of doing it because it's more clear that the function is
generic. Also, because it's so easy to do that why not?
Classes: Classes that have possibly-circular values get gc entries.

Additionally, those classes get the tuple gc marker (which works perfectly
for instances because they have the same layout).

This does not handle classes in themselves (not possible yet) or generic
classes (also not possible yet).