Testing improvements

Things that everyone should care about:

1. All unit tests have been switched over to a much simpler test syntax with better reporting and test-running capabilities thanks to `py.test`.
2. Non-IPython notebook examples have been removed.
3. IPython notebook examples have been updated to new syntax.
4. All tests for which it makes sense now test all nonlinearity types, not just `nengo.LIF`.
5. Testing for Python 2.6, 2.7, and 3.3 compatibility can now be done locally (i.e., without having to wait for Travis-CI to build) using `tox`.
6. There is a new unit test that ensures that none of the IPython notebook examples raises an exception. This doesn't check for correctness, but it does at least ensure that examples will run.
7. Travis-CI now also checks for PEP8 compliance, and some other easy-to-automatically-spot errors using `flake8`. This is also available locally in the `pep8` tox environment.
8. Made sure that we are fully compliant with PEP8. Also ensured that the minimum cyclomatic complexity in functions is 10 (with a few explicit exceptions).
9. Travis-CI now runs coverage information as well, which is published to coveralls.io (see [example output](https://coveralls.io/builds/416176)).

## How to run tests once this is merged

First, you will need to install `py.test`, and I recommend installing the `pytest-xdist` plugin.
```
pip install pytest pytest-xdist
```
Now, in the nengo directory, you can run tests with
```
py.test
```
If you would like to use more than 1 core to run tests (which gives quite a bit speedup) you can do the following (if you have `pytest-xdist` installed):
```
py.test -n 8
```
where 8 is the number of cores used.

It's sometimes nice to check locally if you code runs properly on Python 2.6, 2.7, and 3.3. It's also nice to make sure your code is PEP8 compliant. To do this, install `tox` (either `pip install tox` or `apt-get install python-tox`) and run
```
tox
```
Again, if you would like to use more than 1 CPU core, you can do
```
tox -- -n 8
```
Finally, `setup.py` is configured to run `tox`. The following:
```
python setup.py test
```
is essentially the same as running `tox`.

## How to write tests once this is merged

Now, you no longer have to use `unittest`, and wrap your tests functions in a `SimulatorTestCase` subclass. You can just write a function that starts with `test_` and it will be run by py.test.

You can do some nice things with "fixtures" (see the pytest documentation for more information). Right now, the fixtures that exist are `Simulator` and `nl`. If your test function takes an argument, `Simulator`, it will be given `nengo.Simulator`. Please use this so that we can use other simulators in other packages. If your test function takes an argument `nl`, all nonlinearity types will be used.

As an example, the following:

```python
def test_basic(Simulator, nl):
    m = nengo.Model()
    ens = nengo.Ensemble(nl(50), dimensions=1)
    sim = Simulator(m)
```

will produce 3 separate tests automatically:
```
test_basic(nengo.Simulator, nengo.LIF)
test_basic(nengo.Simulator, nengo.LIFRate)
test_basic(nengo.Simualtor, nengo.Direct)
```

This is just one of many advantages to using py.test.