Explode

[frankmcsherry]

This PR introduces the explode operator, whose role in life is to move parts of the data that can be aggregated into the diff component, which differential dataflow will aggregate in-place. For example, if we had a collection of (name, salary) pairs and wanted the total salaries by name, the only way to do this within differential dataflow was

employees.group(|_name, salaries, output| 
    let sum = salaries.iter().map(|(sal,cnt)| sal * cnt).sum();
    output.push((sum, 1));
)

This is horrible for several reasons. Other than being verbose, differential dataflow is obliged to maintain the collection of salaries as distinct elements, because we could be computing the median or something horrible like that. We would prefer a way to explain to differential dataflow that it can accumulate the salary components.

The explode operator does this, mapping each input datum into a sequence of pairs (data, diff), and producing the collection that is the accumulation of all of the diffs for each of the datas produced. The example above would become

employees.explode(|(name, salary)| Some((name, salary)))
         .count();

In addition to being more efficient, this is meant to be more idiomatic, in that our program does not need to understand the underlying differences, etc. It also means that we can introduce other operators, filter, map, join, etc before doing the final count accumulation.

It may be that we need a more idiomatic name, but I'm not entirely sure what to use (accumulate, because the result is an accumulation?). Any thoughts here would be welcome.