Add lexing for JOIN
Add parsing for fully-qualified column names

This stuff seems to get really complicated when assigning aliases to join
results and things like that, but the current approach of just using
dot-separated strings should work for simple cases.
Add basic parsing/compiling for table aliases

This needs to be made more sophisticated in the future to account for more
complex dot-separated names, but this seems to work for simple cases.
Dot-separated statements are parsed in a way that it looks like a regular
string with dots in it. When we compile a select with an alias, we replace type
context values to include that alias.
Move TypeContext into its own file
Use the TypeContext factory method everywhere, rename it to be shorter
Add another GROUP BY test

I wasn't sure if I got this case right, but it turns out I did.
Overhaul the way columns are referenced

Previously, I was doing string operations to separate the (optional) table
component and the column component from a column reference. This doesn't work
for more complicated cases (e.g. figuring out what to do with "a.b.c.d"), so
this commit explicitly uses a table and column name whenever we have information
about a column or reference a column. In many cases, the table is None.

This commit also adds the concept of implicitly-selected columns. For example,
if you select "value + 1" in a subquery, the value column can be referenced in
the outer query, and it looks like the fully-qualified name is allowed. I
implemented this by going through all non-aggregate select fields and adding
them to a special "implicit column context" on the type context. The implicit
columns need to be a special case, since they shouldn't show up in SELECT * and
things like that, and they shouldn't cause ambiguity errors if they conflict
with regular columns. This stuff seems to work pretty well at the compile step,
but the evaluator step probably doesn't handle them correctly. There are also
some known edge cases where we still differ from BigQuery.

I also added some tests that I believe are currently failing. They'll be fixed
in a later commit.
Allow subquery aliases to be used for implicit column references

For now, the approach is to replace all implicitly selected columns with the
alias. In particular, this lets you alias a subquery and use table columns with
the subquery alias (and not the original table alias), although I think there
are a few cases where this still gets things wrong.
Get rid of some low-priority TODO tests

They're still valid tests, but exactly emulating the ways that GROUP BY can fail
doesn't seem super-important right now, and I want the tests to be green.