Added a bare return sample.

This case emits a distinct opcode (OP_RETURN0), to ease decompilation.
Implemented IF statements.

The parser stage in lang.g emits each if...[elseif...]*[else...]?endif
sequence as a flat subtree, with nodes *backwards* to make jump emission
easier. This is minimally signposted in both compilation stages, since it's
really fucking surprising.
Forbid ELSEIF...ELSE...IF sequences.

lang.g can never generate these, but compiler.g would have generated crazy
op sequences for them:

    ^(ENDIF
        ^(ELSEIF elseif_cond elseif_body)
        ^(ELSE else_body)
        ^(IF if_cond if_body)
    )

becomes

    if_cond
    ^(OP_IF $ELSE)
    if_body
    ^(OP_JUMP $ENDIF)
    $ELSE:
    else_body
    elseif_cond
    ^(OP_EIF $ENDIF)
    elseif_body
    ^(OP_JUMP $ENDIF)
    $ENDIF: ...rest of program...

which isn't right in the head.

(If OP_EIF was just OP_IF, this would look a lot like, but not identical to,
two if-statements with some intervening code. Note the target of the jump at
the end of if_body.)

We now only permit ^(ELSE else_body) as the *first* child of an ^(ENDIF ...)
tree.
Use a less-surprising production for list_body.

The existing production "worked" but relied on lying to the tree rewriter to
suppress the error when list_literal's list_body produced no tree. Now the
production assumes list_body is optional, rather than assuming it
might be empty, making the rewrite rule easier to grok.
Added support for WHILE statements.

This also adds support for bare identifiers as expressions, to exercise cases
like `while identifier_while (identifier_condition) identifier_body;
endwhile`. To make this parse cleanly, the loop identifier is tagged in the
parse tree as a ^(LOOP_TAG ...) subtree. This avoids ambiguous parse trees
such as

    ^(ENDWHILE
        identifier_while
        identifier_condition
        identifier_body
    )

I've called it LOOP_TAG in the hopes that the same construct can apply to
other kinds of loops.
Merge branches 'while' and 'saner-list-body'
Parse empty statements correctly again.

The rewrite from statement to simple_statement accidentally permitted the
statement consisting of `;;` but not of `;`, because one production was
attached to the wrong rule. Moving the bare-semicolon case to `statement`
means empty statements are once again discarded sanely.
Merge branch 'empty-program-fix'

Conflicts:
	lang.g
Generate code for for-over-list.
Include the entire list_tail when compiling ^(LIST ...) trees, not just the first tail.

List literal compilation was dropping list elements on the floor.
Merge branch 'list-compilation-is-broken'
Use real tokens for list expressions.

Using token indexes to generate jump targets (and generating jump targets from
expression subtrees) means that every token that might be used to generate a
jump target LABEL needs to have an index, i.e., it needs to come from the
token stream.

I've replaced the LIST fictional token during parsing with the '{' token from
the underlying token stream. This is pretty ugly, but it keeps code generation
simple.
Implemented for-range loops, gutted numeric lexing.

Distinguishing ranges ([1..3]) from pairs of floats (1. .3) is surprisingly
hard with a strict LL(*) lexer. lang.g now contains a hairy decision tree that
examines incoming input and classifies it manually, rather than relying on
matching to do classification directly. This was inspired by the Antlr FAQ:
JavaFX has an even hairier decision tree for hex, octal, float, time, dot, and
dotdot tokens
(http://www.antlr.org/wiki/display/ANTLR3/Lexer+grammar+for+floating+point%2C+dot%2C+range%2C+time+specs).

Needless to say, I'm "thrilled" by this.
Merge branch 'for-loops'

Conflicts:
	compiler.g
Compile FORK statements.

Fork statements result in a secondary code vector (one per fork statement), so
I've introduced a new top-level element in the compiler.g output: FORK_VECTOR.
The intent is that it contains the ops destined for a new vector. It also
appears in OP_FORK and OP_FORK_WITH_ID ops, as a way of referencing the new
fork vector, as with LABEL in jump instructions.
Compile try/except statements.

Unlike if/elseif/else statements, the parse tree is the right way around. (We
don't have to generate a linked list.) However, the first except in a try is
special-cased to generate different op sequences so that the *last* except
doesn't end with a no-op jump. This differs from bare-if statements (which do
end with a no-op jump) intentionally.
Parse and compile try/finally statements.

This is a much simpler code sequence to emit, having a fixed number of arms.
However, I had to restructure the parse stage to left-factor TRY <statements>
out of two otherwise-similar rules. (Kids: don't make left-ambiguous grammars.
It makes parser folk cry.)
Remove duplicate label generation in identified while.

This was generating sequences like

    while_foo:
        <expression>
    while_foo:
        WHILE_ID identifier done
            (while body)
            JUMP while_foo
    done:

which is, ah, nonsensical. The second `while_foo` label is incorrect, but the
first is the correct jump target for re-evaluating the loop condition.
Merge branch 'labelled-while-jump-targets'