Runner should support multiple formatters

I may be missing an obvious answer to this problem, but I think it would be useful if konacha's runner supported multiple output formats.

My immediate goal is to output test results in JUnit format for consumption by Jenkins, but I can imagine people wanting to output in a variety of formats if konacha supported it.

Right now the runner's logic for managing the reporting and formatting tasks is all jumbled together. The runner should retrieve the test results from mocha and then call methods on a separate Formatter class that can handle outputting the results.

RSpec has a number of default and customized formatters available, including two that output in JUnit (see https://github.com/nicksieger/ci_reporter/blob/master/lib/ci/reporter/rspec.rb and http://www.natontesting.com/2012/05/25/rspec-junit-formatter-for-jenkins/). It would be really nice if existing RSpec formatters such as these could be plugged into konacha.

## RSpec Protocol

I suggest that the runner implement the same protocol as `RSpec::Core::Reporter`. Here is the description of the calls the reporter is expected to make (see https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/formatters/base_formatter.rb)

    The Reporter calls the Formatter with this protocol:
    
    * start(expected_example_count)
    * zero or more of the following
      * example_group_started(group)
      * example_started(example)
      * example_passed(example)
      * example_failed(example)
      * example_pending(example)
      * message(string)
      * example_group_finished(group)
    * stop
    * start_dump
    * dump_pending
    * dump_failures
    * dump_summary(duration, example_count, failure_count, pending_count)
    * seed(value)
    * close

In addition to implementing the above protocol, konacha would also need to pass doubles for the `RSpec::Core::ExampleGroup` and `RSpec::Core::Example` classes. The documentation isn't very thorough, so this may not be 100% accurate, but these appear to be the publicly-accessible attributes for each class:

### `Example`

    metadata (Hash)
      :full_description (String)
      :execution_result
        :status (String)
        :started_at (Time)
        :finished_at (Time)
        :run_time (Float)
      :exception (Exception)
      :pending_message (String)
      :file_path (String)
      :pending (Boolean or String)
      :location (String)
      :description (String)
      :line_number (String)
    All metadata keys (delegated)
    pending? (alias of pending)
    exception (Exception)
    options (delegated to metadata)
    example_group (ExampleGroup)

### `ExampleGroup`

    metadata (Hash)
      :full_description (String)
      :file_path (String)
      :location (String)
      :description (String)
      :line_number (String)
      :described_class (?)
    description, described_class, file_path (delegated to metadata)
    display_name (ailas of description)

Nothing here looks unusual or difficult to obtain, with the possible exception of :described_class.

## Implementation Thought

Stipulated that I don't know much about how the runner _or_ mocha works...it seems that nearly all of the core RSpec Reporter events have functionally-identical mocha emissions:

    * start => start
    * zero or more of the following
      * example_group_started => suite
      * example_started => test
      * example_passed => pass
      * example_failed => fail
      * example_pending => pending
      * message => [no obvious equivalent]
      * example_group_finished => suite_end
    * stop => end

Right now konacha's mocha reporter stores test results in a `Konacha.results` array and "dots" for output in a `Konacha.dots` string. The runner polls for changes to `Konacha.dots` until mocha finishes, at which point it interprets `Konacha.results` and outputs test failures.

Could we instead capture mocha's emissions in a `Konacha.events` array that includes an object similar to the current `results` object? Then the runner could poll for additions to that array, create or update the correct `Example` or `ExampleGroup` object and fire off the corresponding RSpec-protocol event for the mocha emission in question.

If this approach seems reasonable and desirable I can put together a pull request, but I wanted to get feedback first.

Thanks!