Emitter: Move various static functions with the helpers.
Emitter: Use the new comment style, simplify a lot of comments.

Some comments, particularly the compound op comment, were far, far too
verbose. I need to work on that. I commented a few functions that didn't have
it too. A few functions were pulled up into the 'helper' area too.
Emitter: BLOCK_* defines are numbers, not flags.

A long time ago, I thought that these might be useful as flags. However, that
time never came. These are not flags, so define them as numbers so that there
will be no confusion in the future.

IS_LOOP_BLOCK was changed to write out a separate check for each line, but
that's a small price to pay.
Emitter: Create lily_emit_change_block_to for block transitions.

This function handles the common parts of checking that 'elif', 'else', and
'except' are valid. The old function 'lily_emit_change_if_branch' is now gone.

With this, block transitions (if -> elif -> else and try -> except) are now
unified in one area, resulting in some code reduction. Also, the block
validity checking seems more sane.

This also presents a unified area to add future block transitions to.
Emitter: Merge lily_emit_return + lily_emit_return_noval, fix an old bug.

This change means that the parser can parse a return value if needed, and give
the same function a valid ast, or NULL.

Additionally, a bug was discovered where the parser would crash when return
expected a value, but was given a function that did not return a value. This
bug has been around for...longer than I want to think about. I added a test to
pre-commit-hook.py to make sure the bug does not come back (though I doubt
that it will).
Emitter: 'do...while' now uses lily_emit_eval_condition.

The only difference between the function it used and the new one is that a
different jump block was being written. I also cleared out some comments that
really weren't that important within lily_emit_eval_condition.
Emitter: eval_enforce_value. The end of 'ast->result == NULL' checks.

I noticed a pattern where lots of emit stuff was checking that the ast that it
evaluated returned a value. An ast can potentially not return a value if the
top of it is a function that doesn't return anything. print and printfmt are
both cases of this.

The emitter's call eval DOES check that a function returns a value if
necessary if that function is in another tree. However, with things like 'if',
'show', 'raise', etc., there's no 'if'/'show'/etc. tree to wrap around the
call.

Anyway, I wish I had thought of this a long time ago, because "crash when this
doesn't get a value" has been an issue more than once.
Emitter: Drop 'self' from type_matchup (not used).
Emitter: Some shuffling of exported functions, a new big block comment.

Yay for more organization!
Emitter: Remove unused lily_emit_add_save_var prototype.

This...I believe is a leftover from before Lily went from address-based to
register-based. Off the top of my head, I'd guess that's been about half a
year or more.
Emitter: Organize emitter's header file a bit.
Parser: Allow blocks to handle non-word expressions.

This allows things like 'if whatever: 1' or 'if whatever: [1, 2, 3]'. It might
be useful for a repl later. But even if it isn't, it might be useful for
chaining expressions together.

Consider something like:
    [1, 2, 3].each( ... )
or
    "1,2,3".split(",") # ...

...Okay, I got nothing. But it's easy to do and might be useful later. If it
proves to be relatively useless, then it's also easily removed.
Symtab+Parser: Split get_intnum_literal...and fix it. :(

The idea behind grabbing for a literal with a value is that the symtab is
supposed to see if it has a literal with that value. If it does, the literal
that already has the value is returned. Instead of, you know, just blindly
making another literal.

Well...it turns out that at some random point, lily_get_intnum_literal had a
very important bit missing. A 'ret = lit;' was needed before the 'break'. But
since that wasn't there...integer and double literals were not unique.

Sanity.ly beforehand:
	3,930 allocs with 432,309 bytes used.
After:
	3,365 allocs with 409,709 bytes used.

-565 allocs, -22,600 bytes used.

Additionally, the broken up functions don't require a lily_raw_value, or a
class. This allowed some code to be removed from parser, which is nice.