Fixed Context copy construction doubling in Python bindings.

Because we didn't specify the argument type as a reference, boost::python was copy constructing the context just to make a temporary to pass to the copy constructor.
Added optimised Context copy constructor.

Up till now, every Context held a unique copy of every entry, and copy construction therefore incurred a lot of overhead :

- Memory allocation
- CopyContext machinations in Cortex
- Reference count management

The new copy constructor accepts an Ownership argument that allows the Context to simply reference the data held by the original context rather than making copies. In the Shared mode, the new Context references the same data and owns a reference to it. In Borrowed mode, the new Context references the same data but doesn't even increment the reference count. Using the benchmark in ContextTest.testManyContexts(), Shared mode takes 16% of the runtime of Copied mode, and Borrowed mode takes 14%.

The new constructor isn't used anywhere yet, but the intention is to use Borrowed mode for all the temporary context created during compute() implementations. This is where performance is critical, and also where we can easily meet the constraint that the source context must outlive the new one.
Further optimised Context copy constructor.

The boost::flat_map copy constructor is significantly faster than iterating and inserting elements ourselves, even when we reserve memory upfront and provide what should be the perfect insertion hint. The improvement is more than enough to offset a second iteration over the copy to patch it up with what we want.

The ContextTest.testManyContexts() shows the following reductions in runtime for each mode :

- Copied : 13%
- Shared : 40%
- Borrowed : 54%

Borrowed mode now runs in 66% of the time of Shared mode, and 3% of the time of the master branch.