Fixed IPR bug where shaders could leak onto the wrong objects.

We were using the "scopename" parameter to describe where the shader edits belong. As it turns out, that is treated as a regular expression, and partial matches are accepted. That meant that edits were leaking on to similarly named objects. We now use the "exactscopename" parameter to target the shader edits instead.
Fixed bug with references containing non-default plug values.

The problematic sequence of operations was as follows :

- User creates a Box and promotes a plug to it.
- User changes the value of that plug to something other than the default, and publishes it as a reference.
- User references in the file, and sets the plug back to the default.
- User saves the new file, but the plug value is not serialised, because it is at the default.
- User loads the file again, the plug value has reverted to the one in the reference.

The fix employed here is to always serialise all values for plugs held directly on a Reference node. It may be nice to have an explicit means of specifying this behaviour via a plug flag or some other mechanism, so that the ValuePlugSerialiser doesn't need explicit knowledge of References, and we can use the same mechanism in other nodes where necessary. I'd like to leave this for future consideration though - I think we'll learn more and have further requirements/use cases when we come to look into implementing GiftBoxes.
Added a FreezeTransform node.

Fixes #822.
Merge pull request #846 from johnhaddon/freezeTransforms

Added a FreezeTransform node.
Merge pull request #840 from johnhaddon/iprBugFix

Fixed IPR bug where shaders could leak onto the wrong objects.
Merge pull request #844 from johnhaddon/referenceDefaultValueFix

Fixed bug with references containing non-default plug values.
Bumped version to 0.95.0 and updated Changes file.
Added support for Box data to CompoundDataPlug.
Added BoxPlugValueWidget class.
Added crop window to StandardOptions node.

Fixes #688.
Renamed BoxPlug min() and max() methods to minPlug() and maxPlug().

This keeps them in line with all the other plug accessors elsewhere.
Improved CompoundDataPlugValueWidget alignment for box plugs.

The plug label now appears at the top rather than floating in the middle. Applying the fixed size really isn't a great idea, but I've spent all morning seeking alternatives without luck. The best attempt was to set the QLabel stylesheet to have border=0px, padding=1px and margin=0px, which although different to the QLineEdit stylesheet, would give an equivalent height for standard (no HTML styles applied) text. Unfortunately that caused the layout to jump when the summary text in the collapsible headers for StandardOptions nodes went from "" to "something".
Derived Context::Scope from boost::noncopyable.

Because copying them makes no sense whatsoever.
Added GAFFERTEST_ASSERT macro.

This allows test failures on the C++ side to be reported to Python, rather than just exit as they did before.
Reimplemented Context storage using boost::flat_map.

This gives a pretty decent performance gain over the old CompoundData storage. The synthetic test in IECore.ContextTest.testManyContexts() shows ~40% reduction in runtime for copying a context with 20 entries (a fairly typical size), and ~45% reduction in runtime for a context with 200 entries. A less synthetic test involving an Instancer node with 10000 instances shows ~15% reduction in runtime.
Used anonymous namespace to hide ContextBinding details.

We were using the static keyword before to hide the function, but that did nothing for the structs - anonymous namespace hides them both.
Added _copy argument to Context::get() bindings.

The rationale for this is explained in the comment in ContextBinding.cpp. Although this new feature may eventually have uses of its own, it's primarily needed right now for unit tests for the upcoming Context optimisations.
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.