Builder no longer modifies model

This is done mostly by not storing what the builder generates.
Some things that are necessary, like gains, biases, and encoders,
are explicitly stored in the builder's data dictionary,
which is passed onto the simulator. This forms the start of
the probe changes, but a lot of work still needs to be done.

The data dictonary passed onto the simulator is accessed as such;
i.e., the Simulator.data function has been changed to a dictionary.
Or, a class that exposes a dictionary like interface;
in actuality it is a mapping called a ProbeDict.

Neuron types were modified in order to not change them.
Rather than setting gains and biases, they are returned,
and must be explicitly passed to the `rates` function.
This almost means, however, that one neuron object can
be passed to multiple ensembles, which is good.

One final thing is that the SimulatorProbe is now gone.
The probe itself is used as a key to the data dictionary,
which isn't great because then the Probe objects are modified,
but this will change when implementing the new probes.
Removed some unnecessary parts of objects

Specifically:

- Connection.eval_points (now bare attribute)
- Ensemble.neurons (now bare attribute)
- Neurons.default_encoders
- Node.size_in, Node.size_out (now bare attributes)
- Node.__deepcopy__
- PythonFunction.__deepcopy__
- Probe.dimensions
Probes no longer modified in build

- eval_points stored separately (like bias, gain)
- build_probe doesn't store things on the probe
Builder refactoring

- Added BuiltModel and NeuronsBuildState objects,
  which contain the artifacts of the build process
- Refactored Builder class to construct these objects
  and made other simplifications
- Organized the test cases a bit better, and ensured
  that previously skipped tests run properly
More builder refactoring

- Extended the idea of NeuronsBuildState to all objects that
  have build artifacts, and exposed them through
  the data dictionary (i.e., the probe system)
- Reverted builder to a callable class
Nengo objects now have unique keys

This makes them properly comparable and hashable.

It's implemented by giving the model the responsibility for
assigning keys to objects. Right now, those keys are generated
by initializing them at the hash of the model's label
(in order to avoid key collisions for multiple models)
and then incrementing for each new object.

`Model.objs` and `Model.connections` are now dictionaries
so that keys static. Every object remembers its key
(`obj.key` or `connection.key`) so that it's easy to
retrieve objects from the model using only the key.

There's definitely room for improvement here, but it does work.
Open for suggestions on better (perhaps more meaningful) keys.
Added test for Model save/load
Readded test_seeding

- In test_builder
- Looks at the built model's params
PEP8 fixes for new version of pep8