Added two new decoder optimization routines.

- they may be faster in some circumstances
Renamed pytest `benchmark` option to `benchmarks`
Added tests for new optimization routines.
Added heuristic to choose the number of eval points.

- fixes #290
Added benchmarks for number of eval points
Added check for empty activities matrix
Added tests for decoder solvers.

- also fixed bug with size of `lstsq_L1` output
Suppressed Python 3 flake8 errors.
Added `block_conjgrad` test.
Added nnls decoder solvers and tests.

- Added three non-negative least squares (nnls) solvers,
  which are based off the `scipy.optimize.nnls` method.
Small improvements to `utils`

- Added a function for plotting general data as an image with
  sensible axes
- Fixed a warning in `numpy.py:array`
Added firing rate estimators

- use either kernels or ISIs to estimate firing rates from spikes
- put these functions in a new file `utils/neurons`
- added some rough tests for these functions
Added adaptive LIF neurons

- made one `SimNeurons` object in the builder, rather than
  having `SimLIF`, `SimLIFRate`, etc.
Nodes can handle functions that don't return a value.

Fix for Issue #324
Set seed in `test_integrator`.
Added filter to direct connections where filter < dt.

Fix for Issue #319
Changed Connections to use "synapse" instead of "filter"

See Issue #283
Changed Probe to use "synapse" instead of "filter"
Added maxint to numpy.py

- This is used in builder instead of the old helper `random_maxint`
- Also edited `rmse` a bit; added docs, kwargs
Made builder pluggable

This means that modellers can create their own neuron types
or NengoObjects or learning rules, etc., and inject them into
the reference simulator. Granted, this requires some pretty
advanced knowledge of the entire codebase, but it's important
that something like this is at least possible.

More concretely, the main change is to move a few things from
Builder into Model, and then restructure Builder such that
build functions register themselves with Builder,
and the only function that is ever really called is
Builder.build, which finds the correct builder function and
calls it with the passed arguments.
This makes it possible to override build functions
and make objects with associated build functions.
It also provides a consistent interface through which
to build an arbitrary Nengo object; now, regardless of the object,
calling Builder.build(object, model=model) will insert
the appropriate build artifacts into the passed model
(if a build method has been associated with that object type).
This opens up the possibility that the user can do the build
manually, and pass a built Model to the simulator.
This is definitely not the normal use case, but we do this
in `test_simulator`, so it's now possible to pass in a model
instead of a network to the simulator (but the network must
be explicitly passed None to do so).

Other changes
- Cleaned up docstrings in builder.py
- Moved `assert_named_signals` into Signal and added test