Remove mapMany function

This duplicated F# core behavior from Seq.collect
Remove generic dependency on core run function

The generic runner was not really helpful in order to polymorphically
handle events, which should be needed in order to e.g. be able to select
different output formats at run time
Extracted code to new function

This allows us to test the bulk of the main function without actually
having to load assemblies with examples
Use reporter interface for generating exit code

The reporter types had two different responsibilities
 - Perform the intended reporting (write to screen or file)
 - Report if the test run was a success for the runner's exit code

By creating a specific reporter for the sole purpose of determining if the
test is a success or failure, each reporter now has only one
responsibility.
Removed Success property from non-generic reporter
Changed ReporterWrapper to interface type

This could make it easier to create new reporters?
Changed changed exit code reporter into a class

This simplifies the code
Renamed ReporterWrapper to IReporter
Moved IReporter to TestReport.fs

It was temporarily placed in Runner.fs to allow refactoring of how the
runner would report to the reporter without affecting other code to begin
with.
Moved TreeReporter functions to higher scope

This allows us to use them from a new reporter type, natively implementing
IReporter
Refactored reporter test double
Removed unused functions
Moved ExitCodeReporter and wrapReporters to core

We will be needing them for the refactored runSingleAssembly
Removed old version of tree reporter
Refactored reporters to use an interface type

The original reporter implementation allowed each reporter to specify a
type of data, containing the collected data during a test run. This forced
the actual runner to be generic, with the type of report data as the
generic type parameter.

This made it difficult to decide which reporter to use at runtime, as we
have to contruct generic types at run time, which is not really nice.

And it made it even more difficult to use multiple different reporters,
e.g. one for writing result to the std out, and one for outputting a
report file, e.g. in JUnit xml format.

By defining a non-generic interface type for a reporter, these two
problems are eliminated.

This does however create a potential problem in the future, how to gather
results from test execution when tests are running in parallel - a problem
that the old implementation could potentially have handled better.

But parallel test execution is not going to be implemented in the near
future.
Wrap paket in mono on build server