Remove SBTRunner -- replacement coming.
Simplify classpath handling a bit.

It's still utter madness, so -- for an extra sanity check --
print the banner for every test run.

The classpath used for tests (modulo additions for certain test cases)
is `fileManager.testClassPath` (or `testClassPathUrls`).

Ideally, we should get rid of all this custom logic in `FileManager`,
and let the build tool figure out the classpath, with partest taking
it from there.
Reduce mutation, avoid Scala classes in test-interface

  - Initialize FileManager in one go, instead of with lots of mutations.
  - To allow calling partest reflectively from sbt's test interface,
    across Scala versions, make signature of AntRunner pure Java.
sbt test-interface for partest

It reflectively calls `SBTRunner`.

Enable it in your `build.sbt` as follows (from the scala-xml build):

```
// for testing with partest (the binary version must be SBT's scala version):
libraryDependencies += "com.typesafe" % "scala-partest-interface_2.10" % "0.1" % "test"

testFrameworks += new TestFramework("com.typesafe.testing.partest.Framework")

// the actual partest the interface calls into -- must be binary version close enough to ours
// so that it can link to the compiler/lib we're using (testing)
libraryDependencies += "org.scala-lang" %% "scala-partest" % "1.0" % "test"

definedTests in Test += (
  new sbt.TestDefinition(
    "partest",
    // marker fingerprint since there are no test classes
    // to be discovered by sbt:
    new sbt.testing.AnnotatedFingerprint {
      def isModule = true
      def annotationName = "partest"
    }, true, Array())
  )
```

You can now invoke partest in SBT using the `test` command.
Further clean up classpath handling

  - remove mutation, code duplication
  - allow versioned jars for scala-library etc by looking only at prefix
  - specialized lib must come first
  - don't crash when codelib not found (e.g. for stand-alone scala-xml)
  - scalacheck classloader: instantiate framework directly
  - make fileManager lazy to avoid NPE
Reliable initialization of test source path

`testSourcePath` determines where we look for tests, relative to the `testRoot`
As `testSourcePath` and `testRoot` are mutable, all jar paths that depend on it
may change as well.

We don't use system properties to configure partest internally,
as their behavior depends on the security policy in place.
ant, for example, does not allow overwriting properties.

TODO: make all of this immutable, but that's pretty involved.
A lot of stuff depends on it (all the more reason to refactor)
Remove FileUtil in favor of FileManager consolidation.

Methods independent of FileManager state are in the companion.

While I was at it, also swapped the sense of diffing check and log,
so that it's more natural (original = check, revised = log).
Remove more dead code: timings
Inline FileManager.JAVA_OPTS as it's used only once
Consolidate `RunnerManager` & `DirectRunner` as `SuiteRunner`

Test suite arguments now `SuiteRunner` constructor arguments.
`FileManager` instance focusses on managing classpath.
Pass `testSourcePath` as `SuiteRunner` constructor arg
Locate library/reflect/compiler via classloader

This is more precise than scanning the urls manually, and fits better with
running partest from build tools, where we resolve the class path using maven/ivy.

The main mode of running partest should be to let some other tool handle dependency
resolution and setting up the classpath, and partest should just take that path,
and work from there. Ideally, its only knowledge about the classpath is the
holy trifecta (library/reflect/compiler).

The core idea is to ask the loader for the code source of a representative class:

```
val classLoader = ScalaClassLoader fromURLs (testClassPath map (_.toURI.toURL))
val canaryClass =
  name match {
    case "library"  => Class.forName("scala.Unit", false, classLoader)
    case "reflect"  => Class.forName("scala.reflect.api.Symbols", false, classLoader)
    case "compiler" => Class.forName("scala.tools.nsc.Main", false, classLoader)
  }

Path(canaryClass.getProtectionDomain.getCodeSource.getLocation.getPath)
```
Remove dead code: `PartestRunSettings`