pub fn import<G>(&mut self, scope: &G) -> Arranged<G, TraceAgent<Tr>>
    where
        G: Scope<Timestamp=Tr::Time>,
    {
        self.import_named(scope, "ArrangedSource")
    }
Copies an existing collection into the supplied scope.

This method creates an `Arranged` collection that should appear indistinguishable from applying `arrange`
directly to the source collection brought into the local scope. The only caveat is that the initial state
of the collection is its current state, and updates occur from this point forward. The historical changes
the collection experienced in the past are accumulated, and the distinctions from the initial collection
are no longer evident.

The current behavior is that the introduced collection accumulates updates to some times less or equal
to `self.get_logical_compaction()`. There is *not* currently a guarantee that the updates are accumulated *to*
the frontier, and the resulting collection history may be weirdly partial until this point. In particular,
the historical collection may move through configurations that did not actually occur, even if eventually
arriving at the correct collection. This is probably a bug; although we get to the right place in the end,
the intermediate computation could do something that the original computation did not, like diverge.

I would expect the semantics to improve to "updates are advanced to `self.get_logical_compaction()`", which
means the computation will run as if starting from exactly this frontier. It is not currently clear whose
responsibility this should be (the trace/batch should only reveal these times, or an operator should know
to advance times before using them).

# Examples

```
use timely::Config;
use differential_dataflow::input::Input;
use differential_dataflow::operators::arrange::ArrangeBySelf;
use differential_dataflow::operators::reduce::Reduce;
use differential_dataflow::trace::Trace;

::timely::execute(Config::thread(), |worker| {

// create a first dataflow
let mut trace = worker.dataflow::<u32,_,_>(|scope| {
// create input handle and collection.
scope.new_collection_from(0 .. 10).1
.arrange_by_self()
.trace
});

// do some work.
worker.step();
worker.step();

// create a second dataflow
worker.dataflow(move |scope| {
trace.import(scope)
.reduce(move |_key, src, dst| dst.push((*src[0].0, 1)));
});

}).unwrap();
```
differential-dataflow/src/operators/arrange/agent.rs