Test seeds are now machine-independent.

Test seeds are generated by hashing the test function name
and filename. Previously, test seeds were using the full
filename, meaning that test results were very machine dependent.
We now use the relative filename (i.e. the name within the
Nengo directory), making things machine independent.

Fixes #586.

Other changes:
- Moved `test_seed` out of `function_seed` to make
  its use more explicit.
- Added a test for the seed that should pass on all machines.
Refactored synapse classes

The major change here is to pull the logic from the builder to the
synapse classes. This makes them accessible from other parts of the
code, rather than being buried in the builder. This results in much
simpler builder code also; there is no need for build methods for
each synapse, unless some internal state of that synapse would like
to be probed (which is still easily done if desired).

The main pattern used for this is very similar to the pattern that
we use in the builder. Each `Synapse` class has a `make_filt` function
that returns a function that can be repeatedly called to filter
a signal. Its use is best demonstrated by `nengo.synapses.filt`
and `nengo.synapses.filtfilt`, which replace the old versions in
`nengo.utils.numpy`, which were specific to lowpass filters;
these new functions take in an arbitrary synapse instance instead,
which also removes the need for `nengo.utils.numpy.lti`.

Implementation-wise, the synapse models make heavy use of
`functools.partial` as a way of binding arguments that would otherwise
need to be repeatedly passed to the `filt` function. Note that
these arguments can be overridden on the partial function returned,
if desired. But in general, it's a somewhat cleaner and more idiomatic
way to achieve what we were doing in the old build methods.

Other minor changes:

- Added `Alpha` and `LinearFilter` to `nengo` namespace
- Removed erroneous `scipy.signal` import in `LinearFilter`;
  we pulled `cont2discrete` into our codebase, so it's not required
Added noise attribute to Ensemble.

This allows for injecting noise drawn from any Distribution.
Technically this also allows for injecting arbitrary current,
as I've done for testing purposes.
Implement stochastic processes for ensemble noise

Includes implementations of a Weiner process, band-limited white noise,
and a generic SampledProcess for sampling from distributions directly.
Expose cont2discrete method in LinearFilter

This is necessary for implementing Brownian noise with distributions
and synapses. The matrix exponential in 'zoh' is broken, so the
'euler' method will be necessary in that case.
A different API for processes

The overall change here is to make processes more like synapses.
That is, they don't need to know their dimensionality ahead of time;
this is instead done when sampling. Similarly, we use partials to
bind state to the function, rather than having it be part of the
object, or be explicitly passed in on each sample.

In addition to an API more consistent with synapses, the big win with
this change is that it is no longer necessary to `copy.copy` processes
when using them in multiple ensembles; `SimNoise` takes care of this
instead (or this could be relegated to the builder in other
`StochasticProcess` use cases). Using `copy` (or, even worse,
`deepcopy`) was a huge problem in earlier iterations of Nengo, so I'm
keen to never use it again. This also makes it possible to use
processes as a default with the config system.

Another behavioral change is that `WhiteNoise` now reflects instead
of loops; that is, once you reach the end of the pre-generated signal
it will replay it in reverse, until it reaches the start, then it will
start playing forward again. This is to limit the discontinuity at
the end of the generated signal; with looping, it will jump from
one value to the next. With reflection, the derivative will flip but
the signal itself will still be sort of continuous. If the derivative
happens to be small at the end of the signal, then it'll be like it's
a continuous signal.

A few more detailed changes:

- Added some docs to `Distribution`
- Naming changes: `WienerProcess` -> `BrownNoise`,
  `LimitedGuassianWhiteNoise` -> `WhiteNoise`
- Removed `GaussianWhiteNoise` to avoid confusion with `WhiteNoise`.
  If someone wants non-limited white noise, they can either pass
  `high=None` to `WhiteNoise`, or make it using `StochasticProcess`
  (as is done in `test_processes.py`)
- Added plotting to `test_processes.py` and `test_ensemble.py`
Removed `utils.functions.whitenoise`

And used the `processes.WhiteNoise` instead. To make this relatively
easy from the end-user perspective, I added an `f` method to
`StochasticProcess` that returns a function that can be used as a
Node output. This basically just wraps the sample function and ignores
the incoming `t`.

Note that when used as a node function, processes maintain state even
if the simulation is reset. This is skirted around in `test_reset`
by using a white noise signal with half the duration of the simulation
so that it repeats. In general, however, we can't expect that node
functions will reset when the simulation resets.
Fix typo.
Remove pytest import in utils.

Fixes #592.
Basic vagrant configuration.
Enable automatic testing in Vagrant Windows box.
Update vagrant box url.