Emitter: Simplify eval_assign's compound expression handling
Emitter: Simplify the global check in assign evaluation.
Debug: Remove unused D_COUNT_DEPTH.

This is unused now that o_package_get/set_deep are gone.
Emitter: Remove impossible check within eval_call, GLOBAL_LOAD_CHECK.

It turns out that it's simply impossible (I think) to have a function call with
the call being a global var. This is because functions have a depth of -1 so
they get marked as readonly (and thus loaded from the vm's func table).

I tried this using 'function f(){}    var v = f    v()' and still could not
trigger this check. I seriously don't think it's possible.

This removes the last user of GLOBAL_LOAD_CHECK, so get rid of that too.
Emitter: Remove unused generic_adjust.
Emitter: Don't assume literal positions in and/or evaluation.

Instead, use the symtab's literal grabbing which isn't hacky.
Symtab: Drop the literal init stage. It's no longer required.

This is no longer necessary now that the emitter's and/or eval uses the proper
functions for getting integer literals. Good riddance.
The symtab now uses lit_chain instead of lit_start + lit_top.

It isn't necessary for literals to have any sort of order. Also, this is
simpler.
Emitter: For loop iteration no longer targets global vars (Fixes #65)

Previously, for loops all assumed that the var given was a local. If the loop
was within __main__, this just resulted in the for loop treating the global var
as a local. Within __main__, this is kind of harmless.

Within a non-__main__ function, the global var's register spot was interpreted
as the spot of a local register. This could result, in, say, the for loop
thinking that the counter was also the loop start (peculiar). In the case of
a global var with a high register spot...I'm assuming there would be a crash.

Anyway, the fix is to create a storage to do the iteration, and do an
o_set_global after the prep and each loop pass. Easy.