Refactor nested tests

This is something of a rewrite to the way nested tests are handled.

Functionally, this changes one thing: nested tests now count against the test plan (like in isaacs/node-tap).

Structurally, this changes the way the `Results` and `Test` objects interact. Instead of having the `Results` object be responsible for managing a flattened list of tests-to-be-run, tests now run their next subtest directly from their own `.end` method. This leads to a (hopefully) easier to follow recursive algorithm for running the tests. This passes against all the current tests (and one I've added), but I'd appreciate people running this branch against their current test suite and reporting failures here, so that I can add more test cases. 

Here's the algorithm described in detail:

The top-level `test` function remains the same, but `Results.prototype.push` has been slimmed down:
  - The test is pushed onto the the `self.tests` array.
  - An `'end'` event listener is attached in `.push` that will run the next test in `self.tests`.
  - All other event listeners (`'prerun'`, `'result'`, and `'test'` are added to each new `Test` object using `self._watch(test)`.

When a test (hereafter referred to as a parent test) is started by the results object:

1. The results object calls `.run()` on the parent test.
2. The parent test defines a sub-test: `t.test('child', function () {...})`. 
  - The `'test'` event is emitted with the new child test.
  - The `Results` object receives the subtest and attaches event listeners using `self._watch(subtest)`. (Recall from above that no `'end'` listener is attached here).
3. `parentTest.end()` is called, either manually or by performing _n_ assertions, where _n_ is the planned number of tests subtract the number of pending sub-tests. _This is a change in behaviour that matches tap_
4. The parent test shifts off the first sub-test.
5. If no sub-test is found:
  - the test finishes by checking the plan, emitting an `'end'` event, etc. etc.
6. If a subtest is found:
  - the parent test attaches a listener to the subtests `'end'` event that will re-call it's own `parent.end()` (which will recur back to step 4).
  - the parent test calls `subtest.run()`, which recurs back to step 2, with the subtest becoming the new parent test.

EDIT: updated description of algorithm after removing 'next' event in e0a6ec7