Added lily_load_special to lily_lexer.h to fix compiler warning.
lexer mode is now independent of file type, and all loads now need it.

This was done to reflect the fact that a particular lexer input type is not
going to always be tagged/untagged. A file may want to be tagged or untagged.
A string may want to be tagged. So all of the parser's load_* calls take the
mode now.

Also, lily_lexer_mode -> lily_lex_mode, to be consistent with lily_lex_state
(both are lily_lex_* after the change). The modes are now lm_tags and
lm_no_tags to better reflect what the modes do.

I also changed lily_load_special to take the mode before the source. This
makes it consistent with the other lily_load_* calls that take the mode before
the particular source.

All of the runners have been updated to now pass the mode they want, except
for apache which had the args reordered.
src/Makefile.am: Add vg-sanity target to run sanity.ly through valgrind.
Parser: Set a starting parser mode. This fixes a potential invalid read.

The potential read occurs when lily_load_file fails since there's an error but
the current parser mode was unset. This also happens now that lexer allocates
entries and that fails.
blastmaster.py: Don't aft all files. It's never found anything. Fixes GH #25.

It's bad enough that the aft of sanity.ly takes so long. But doing an aft of
all files is even worse. I also added some touchups, like stopping when a
test doesn't pass/fail like it should.

All non-sanity.ly tests have been pushed to the front, since they run really
fast now.
vm: Malloc the vm's sipkey. The original goes out of scope.

Discovered this while trying to add hash entries to a var in the apache mod.
I'm surprised that I didn't notice this until now!
Hash entries now deref keys, hash elems now copy key flags.

I found a memory leak while doing apache (again). This time, if a hash has a
str key that has one ref and isn't protected, the str will never get free'd.
So the hash derefs the keys is gets. This seems right, since I think hashes
ref their keys as well.

Additionally, hash element creation copies over keys. This was necessary to
keep the hash elem deref from thinking that a literal key was not a literal
key (and trying to deref it).