Parser: Single-line try, cleave down the huge comment block.
Parser: More comments, make lily_parser into parser_loop.

That function should not be called directly because the caller may not set a
raiser jump, and the caller may not have set a file. Better to let it only be
called through exported API stuff.
Parser: Use an integer sig for new functions by default.

Previously, the parser was calling lily_try_sig_for_class, resulting in one
new empty function signature for each function declaration. Not only was it
made, but because ensure was never done on it, there were -multiple- blank
function signatures made.

Now it uses the signature of integer (of which there is only one), and swaps
the signature of the var created if it needs to do that. The result is 86
fewer allocations within sanity.ly, which is nice.
ast: Remove unused prototype, lily_ast_push_empty_list.

The latter call has not been used since the parser's expression handling was
rewritten.
Drop lily_ast_caller_tree_type, use lily_ast_get_saved_tree instead.
Symtab: lily_new_literal -> try_new_literal.

There are three helpers that the symtab exports for creating new literals.
Each of them saves calling up the class and creating a raw value specifically
for creating a literal. So it's unlikely that what was lily_new_literal would
be used again.
Parser: Actually...use __main__'s signature as a default for new funcs.

...Because using integer causes a condition where it's possible to leak
memory.

1: Parser creates a function var with a bogus signature.
2: Emitter enters it, creating a function val for it.
3: Parser's type collection hits oom.
4: Symtab sees an integer and does not free the function val.

Thanks aft!
lily_ast_enter_tree -finally- takes 2 arguments.

The third argument, an initial value, was initially done as a hack by the old
expression engine to handle function calls. Once expressions were rewritten,
only static accesses of functions used this. So I changed that.

The third argument was NULL 99% of the time, so this is a good thing. :)
ast: Hey unary, use merge_value.

It is not possible to merge unary and have a value as a current, so the checks
being done were all impossible. If this does happen, then parser has some
explaining to do (because it's merging unary like it's a binary).

This started with registers being added (probably an accident) and was then
added to over time as I thought the previous code was sane. Well...it wasn't.
ast: Cleanup comments, and some reorganization.
ast: Cleanup the header a bit and drop ast->arg_top.

It's much easier to simply loop to find arg_top and set it since nothing else
uses arg_top outside ast. There are definitely some more savings in ast field
removal but...

It's a waste of time. Removing that one field saves around 200 bytes of
memory, which is laughable because the current sanity.ly shows a use of nearly
400K for me.
vm: Replace ref assign with lily_assign_value.

Bonus: ref_assign had a bug in that it did a deref before a ref. This is
always wrong, because if a value is assigned itself and has one ref...it will
be collected and then the dead value given a ref (this is bad).
vm: Stop re-implementing assignments. Use lily_assign_value!

To be fair, some of this code came from before there was a lily_assign_value.
However, now it's a lot of duplicated stuff. This sort of thing makes it
easy to have a hidden bug somewhere. o_return_val actually DID have a bug in
it (it was not properly handling returning to any).

But this is more about removing things that are just plain redundant.