We now need a place to push where clauses and other constructs.
We'll need all constructs of a Select statement since that's what
we're eventually building.

This will be used for the v3 planbuilder.

Skeletal code to identify the rightmost route where
we can push individual parts of a where clause.
We also add flags for RouteBuilder and TableAlias
if they're on the RHS of a left join.

WHERE clause filters can now be pushed down, and we
also perform routing changes if applicable.

There are no colvindexes in the new v3 routes. So, we need a better way
to test that the correct vindexes were chosen.

Still need to write more tests.
Subqueries won't be addressed till the end.

We need to know the Order of left and right nodes for the
join builders. This allow us to know the correct path from
the root node to the necessary RouteBuilder.

This part just reuses the filter functions with some slightly
modified rules.

Changed the symbol table to have slices because map is overkill
for a handful of symbols.
Changed select to use rightmost route, just like where clause.

When symbols get resolved, those decisions need to be persisted.
Otherwise, the symbol table evolves and introduces new symbols
that may hide old ones (when SELECT is parsed). A re-resolution
after the fact can produce inconsistent/incorrect results.
In other words, we need the original resolution to be remembered
when we decide to wire things up at the end.

The symtab Find will now return an error if a reference could not
be resolved. It's also now broken out into another function, Vindex,
which returns a Vindex of one can be found for the expression.

Merging FindInScope and Find, because it wasn't clear when to use
what. Now, Find returns an isLocal flag. This forces you to think
if that needs to be checked in the current context.

The previous scheme was hard to implement at execution time.
In the new scheme, every join node knows contains info about
which vars it needs to supply.

A few features are still to be done, like subquery in FROM
clause, but everything is functional end-to-end, and the old
v3 tests are passing against the new code.
Comprehensive tests need to be written, and the code needs
commenting and cleanup.

They're not as different as I thought they were.

We now use the more versatile leftmost(plan) construct.

This containment simplifies paramter-passing across the board.

For more than one level of subquery nesting. The route symbol
table was getting repointed only at the first level. In order
to address this, I'm using a new redirect scheme where a route
can redirect to another route.
In the new scheme we just redirect the current route to the new
one. So, if there are other routes that are redirected to the
current one, they will also get redirected to the new route.

We still don't support joins there, but routes will work.

If the LHS of a join returns no rows, we still need to get
the field info from the RHS. For this, we need to send a
query with an impossible where clause, which is a low cost
way of fetching field info from mysql.

Two routes can be merged if they target the same shard

Field info was being built for every call to join. It was
wasteful for the case of nested loops.

Push functions have been moved as members of the
primitives. This structure will be more convenient
if we add more primitives in the future.

If subqueries are processed last, then we generally get better
plans because other conditions could improve the outer query's
plan first.

Allowing '*' expressions for simple routes. This is for
supporting legacy apps that may still be using this construct.

Renamed some functions for better readability

Adding NEXTVAL as keyword. This lets us control
where this can or cannot be allowed at the parser level.
Also, the argument to NEXTVAL is a table name, which
is technically a different syntax than a normal function.

Sequences for vttablet: initial cut