Symtab: lily_ensure_unique_sig now takes flags, shuffled count to the back.

Flags comes after the class, and the count is now at the end. This makes it
so the last two parameters act as a range of sorts (start, then how many from
there). So it seems a bit sane.

Anyway, flags was added so that vararg sigs work. Otherwise,
    function b(integer a...) { ... }
is the same as
    function c(integer a) { ... }
which is not the case.

Emitter and parser have been updated appropriately.
Parser: Unify inner type collection for all types.

There used to be a separate loop for lists/hashes/tuples versus functions.
It's about the same size with the two loops unified (because of all the state
stuff. However, type collection for functions now uses lily_build_ensure_sig.
Because it uses this function, duplicate siglists are no longer malloced just
to be thrown away. Similarly, the () case was pretty wasteful too.

There's a very, very minor change to sanity.ly's memory usage.

This is just another part of reorganizing the internals of the interpreter.
Parser: A twofer: Cut down if/elif/else, and fix an unknown bug.

The bug was this:

if 1: elif 1: 1

This was because of if dispatching to elif/else directly but only once. The
bug was that the interpreter would report an extra '}' (because the if block
was being popped twice).

Pop 1: if -> elif (last expression, so pop).
Pop 2: if (returned to, so pop).

I fixed this by making if_handler dispatch to elif/else in a loop, and by
making elif_handler and else_handler leave block state alone. For extra
measure, I condensed all of if_handlers block pops to a pop at the end.

This adds a rather strange feature: In a single-line block, every condition
but the last one can be empty. I fully admit that this seems strange and may
not be wanted in the future.

This can be removed in the future, however. To do so, if_handler would need to
check emitter's expr_num before and after each single-line block. A
single-line block should have two expressions per elif: one for the condition,
and one for the statement under it. If you go this route, have things like
break, continue, (and return if it doesn't get an expression) bump up the
expr_num artificially. Otherwise 'if 1: break' will be wrongfully trapped.
Parser: For 'type x = value', push x to the ast properly.

Previously, the parser was using 'lily_push_push_sym' regardless of the depth
of the var. This was technically correct...except that the ast marks it as
a var (global) instead of a local var.

There is a difference to this. An assignment to a global is unlikely to be
optimized by the emitter's optimizing function. The optimization is a small
one (the last instruction is rewritten to write to a local, instead of it
emitting to a storage and then writing to a local).
Emitter: Optimize can be done if the right is a global.

o_get_global can be patched to write to the local value instead of a storage
which gets written to the local value.