Ensure no filtering when `synapse=0`

- fixes #337
Made some notebooks optional in tests

- Lorenz attractor notebook was crashing TravisCI,
  so it's optional now
Changed trange to use arange instead of linspace
Changed `trange` to match length of probe output
Fix for bug related to unconnected Nodes
Added test for unconnected nodes

Also a comment for the fix for this.
Used Simulator test fixture where forgotten

We accidentally used nengo.Simulator a few times where we should
have used Simulator. Whoops!
Using warnings module for warnings

Previously we used logging.warning. However, by default,
there is no logger installed, so they were never being shown.
Warnings are probably worth showing, so we'll use the warnings
module instead.

There was only one warning, it turns out!

Also added logging.captureWarnings to nengo.utils.log.

Fixes #318.
Added system to specify default parameters

This is done at Network level.
Added separate config context stack

A few other changes:
- Added empty configs to Networks by default
- Added more informative __str__ for ConfigItems
- Configs inherit attributes from parents
- Improved docstrings and other cleanup
Improved copy of `Config`

- no longer need to use deepcopy
- added tests for `Config` copying.
Added test for config stack

Also added a check in Config.__exit__ to ensure that we don't
pop the default config off of the stack.
Also added a check in Network.__exit__ to ensure that
the config being popped is the network's config.

Since configs have their own stack, this means that things
get kind of dicey if we change the network's config;
that new config doesn't get added Config.context,
and the old config remains.
Disallowed changing network.config

Just through a property with no setter / deleter,
but should be good enough for now. Added a test to ensure
it's not easy to change. Also tried to give a decent
error message if you do try to change it.
Rewrote configuration system

This previous system was good, but was difficult to change on the fly,
which is necessary for setting object defaults (see PR #329).
This system should support setting object defaults cleanly,
without needing separate classes for each type that will be configured.

The most relevant changes are in `nengo/config.py`. Now, instead of
subclassing, each backend should instantiate a `Config` object
and add extra parameters to it by calling `set_param`.
`ClassParams` and `InstanceParams` are classes similar to
the old `ConfigItem`, but they are also designed to be extended live,
instead of through subclassing.
It is also created automatically by the `Config` object;
`ClassParams` and `InstanceParams` shouldn't be instantiated manually.
Instead, use the `configures` function.

Looking at the tests in `nengo/tests/test_config.py` should give
a good picture of how to use the new Config system.

Other changes:
- builder.Model keeps track of which network is the top level
  network, for possible future use
- network.config is passed in to all build methods called
  by build_network, for possible future use
- Networks get a config object upon instantiation; the config
  object is constructed in the `Network.default_config` function.
- Added a `params` property to NengoObject that returns a list
  of Parameters
- Made all appropriate NengoObject attributes `config.Parameter`s
  so that they share the implementation used by the config system
- Got rid of **kwargs in Connection.__init__
- Configs mess with pickling because of the WeakKeyDict.
  I think there are lots of reasons to not use Pickle though,
  so I got rid of saving / loading networks for now, and we should
  instead do something more intelligent in the future
- Fixed Uniform.__eq__ and Gaussian.__eq__ when comparing to
  other types of objects
Rewrote probe system

This is an attempt to make probes easier to work with in both
the front end and the back end.

Front end changes:

- Objects no longer have a probes attribute or a probe function.
  Their only knowledge of probes is a `probeable` parameter,
  which contains the things that can be probed in that object.
  Note that, with the rewritten config system, we can make this list
  configurable in the same way that other parameters are.
  The main benefit of that being that backends can override the
  default probeable lists on all of the objects.
- Probes are now stored in the network, in the same way as ensembles,
  nodes, etc. are
- Probe is now a subclass of NengoObject
- Connections made as a result of probing are no longer made in the
  front end, which makes networks simpler.

Back end changes:

- The logic for building probes has been taken out of each object's
  build function and put into the build_probe function.
  This is where the magic happens. Now, connections are made
  inside these build function, but those connections are not added
  to the network; they are immediately built.
- For some probes, instead of building a connection, we just filter
  an existing signal. This is now possible (and indeed easy!)
- Model.sig_in and sig_out are collapsed into a single `sig`
  dictionary, which contains other dictionaries of signals.
  For this and for learning, we're needing to keep handles to more
  signals, so this is a much better way to do it than adding
  a new dictionary every time we want to hold onto a different
  type of signal
- Probes now build in a separate step (after all other steps)
Ignore encoders for direct mode populations
Remove specific checks for Direct

This was done in three places where encoders were being set.
Move SignalDict to builder

Also moved a few tests to test_builder, and moved RefSimulator
to conftest.py. No changes, just straight moves.
Fail faster when making Ops

Before, make_step wouldn't be called until Simulator.__init__.
If there was an issue (e.g., shape mismatch) you would get the error
there, which is not very helpful in debugging.
Now, when you add an op to the model, it calls make_step right away
to ensure that it works. It wastes a bit of time during build, but
doesn't make any impact on simulation time, so it's worth it for
the easier debugging.
neurons -> n_neurons and neuron_type

This has an impact on all user-facing code (tests, examples),
so this commit touches lots of files. The underlying object and builder
changes should be pretty straightforward. In general, we're moving
towards only using Ensemble, Node, Network, Connection and Probe
as "first level" objects, and Neurons, Synapses and LearningRules
as "second level" objects. The second level objects shouldn't
be used as keys into signal dictionaries and the like.
This does this work for Neurons; we'll keep doing this for learning
rules and the like next.