The Executor trait wraps a circuit scheduler and decides how many times to run
the circuit per parent clock tick: once for the top-level circuit, many times
for iterative circuits, and 0 or 1 times for a non-incremental circuit (an odd
beast, but that's besides the point here).

This trait is invoked in different ways for top-level and nested circuits: in
the top-level scope, the executor is invoked to commit the transaction and
track commit completion status.  In the nested scope, the executor is invoked
to flush the child circuit operator/track flush completion.  Instead of defining different different methods for these two situations, we
overloaded `start_commit_transaction`/`is_commit_complete` methods to do two
different things, making it impossible to explain what the method is actualy
supposed to do.

This commit introduces separate pairs of methods for flush and commmit
operations.  This is still not perfect, since different implementations need to
implement different subsets of the methods, so we probably want two separate
traits.  We can do that in the future, but this is already much cleaner.

Signed-off-by: Leonid Ryzhyk <[email protected]>

This commit implements two building blocks for various multiway join
algorithms:

* The `Match` operator iterates over common keys of multiple indexed streams,
  calling a user-provided closure for each key. The closure can implement
  standard join semantics, but it can also do soemthing different, e.g., it
  can compute the count of values for each key, which can be used as part of
  wcoj-like schemes.

* The star join operator is a generalization of the 2-way join to compute a
  join of multiple streams on a common join key.  It comes in two flavors:
  - an inner-star-join that works in both root and nested circuits
  - a star-join that supports any combination of inner and outer joins and that
    is only defined in the root scope.
  Both flavors support regular join, join_index, and join_flatmap forms.

  The star join operator is built on top of the `Match` operator.

Star join is a variadic operator that applies to streams with multiple
different value types. It cannot be expressed as a single strongly typed
function. Rather a separate function is required for every distinct number of
arguments. Instead of creating a fixed set of such functions, we define macros
that a client program can be used to instantiate any number of such functions
for every number of arguments required by the program.

Signed-off-by: Leonid Ryzhyk <[email protected]>