Basic benchmarking shows that we're incurring a ~49% overhead from using
Zinc instead of the Scala compiler directly. That is, we wrote a basic
worker that invokes the Scala 2 compiler programmatically via
`scala.tools.nsc.Main`, and found that it was ~49% faster
across-the-board.

This doesn't necessarily mean that we can speed up `ZincRunner` by 49%.
A lot of that time is spent in compilation phases
[added](https://github.com/scala/scala/blob/2.13.x/src/sbt-bridge/scala/tools/xsbt/CallbackGlobal.scala#L166)
by the compiler bridge (implementation of the compiler interface)
itself. There are three of these phases; they're responsible for:
1. Mapping generated `.class` files to sources
2. Analyzing depedendencies between code
3. Producing the analysis information outputted by Zinc

We rely on 2 and 3 for:
- Dependency checking
- Detecting main classes
- Test discovery

We only use 2 and 3, and although it's likely the phases could be
slimmed down to only extract the information we need, implementing them
ourselves would add a lot of complexity to `ZincRunner` and make it
less portable . There's also no guarantee
that we could do a better job.

What can be eliminated is all the overhead related to incremental
compilation. We haven't used incremental compilation for years and have
no intention of re-enabling it.

This commit isn't about ripping out Zinc entirely; we still use Zinc for
the following things:
- Classloading the compiler interface from the compiler classpath
- Implementations of various `xsbti.*` traits and interfaces