Improve performance insignificantly, for style.
Name configure options consistently.
Add function to flip relational operators.
Delete potentially stale unit test directory.
Refactor query expression AST implementation.

This change provides new implementation of the query expression AST data
structure. The old implementation was based on a cumbersome to maintain
style with reference semantics. The new implementation uses a variant-style
architecture where visitors can finally (!) return values. This makes it much
more fun and easy to write visitors which transform the AST and return a new
one. The namespace vast::expr contains several expression visitors.

We finally treat negations correctly as well. Previously the parser pushed
negations down into the individual predicates, which may or may not be what the
user wants. If this is still desired, it would now be trivial to write a new
visitor which simply performs another pass of the AST.

Moreover, the annoyance of extractors only being allowed on the LHS of
predicate has now been removed. That is, data can also occur on the LHS. For
example, it's now possible to write:

        "foo" in :string || 0.5 == :real

Further, we have fixed and optimized the candidate checks of results:
previously the candidate check returned always true, returning false positives
in cases where the index was not exact. We now construct a special AST for each
event type, which is much more efficient than relying a generic evaluator
visitor. In a way, we "compile" special ASTs for each event type when we have
an event in the query for the first time. To illustrate, consider this example:
The expression ":real > 4.2 && :int == +1337 || :duration > 1h" contains three
types. If the event under candidate check neither has a type real nor a type
int, the optimizer reduces the original AST to ":duration > 1h". After weeding
unnecessary operands, the optimizer compiles the type extractor for duration
into exact offsets. Say the event is a record of this form:

        r: record {x: duration, y: string, z: duration}

Then the optimizer compiles ":duration > 1h" into a disjunction of this form:

        (r@0 > 1h || r@2 > 1h)

The net effect is that a candidate checks is now a constant-time for each
predicate, because there is no more "live traversal" necessary.