Work around weird AbstractMethodError

Could not figure it out, so resorting to brain dumping.

something with private classes and defaults,
the default getter will be in the private companion module,
but there's no accessor to get the module???
maybe something related to make non-private of the accessor?

while running the repl or, e.g., the test presentation/ide-t1000567
AbstractMethodError: scala.tools.nsc.interactive.Global$$anon$5.scala$tools$nsc$typechecker$Contexts$$BufferingReporter()Lscala/tools/nsc/typechecker/Contexts$BufferingReporter$;
 at scala.tools.nsc.typechecker.Contexts$Context.makeSilent(Contexts.scala:518)

in progress minimal repro:

```
package a

class Reporter

class Global {
  lazy val analyzer = new {
    val global: Global.this.type = Global.this
  } with Analyzer
}

trait Analyzer extends AnyRef with Contexts  {
  val global : Global
}

trait Contexts { self: Analyzer =>
// the accessor to get to ContextReporter's companion object
// to get the default for x is not emitted for some reason
// the expected accessor is the non-private version
// `def scala$tools$nsc$typechecker$Contexts$$BufferingReporter: scala.tools.nsc.typechecker.Contexts#BufferingReporter$`
// (as seen in the AbstractMethodError's message)
  abstract class ContextReporter(x: Any = null) extends Reporter
  private class ThrowingReporter extends ContextReporter

  class Context(a: Any, private[this] var _reporter: ContextReporter = new ThrowingReporter) {
    def reporter = _reporter
  }
  object NoContext extends Context(null)
}

package b

trait ReplGlobal extends a.Global {
  // this anon class corresponds to scala.tools.nsc.interactive.Global$$anon$5 in the above AbstractMethodError
  override lazy val analyzer = new {
     val global: ReplGlobal.this.type = ReplGlobal.this
   } with a.Analyzer { }
}
```
Towards more privacy for _reporter.

Move code that manipulates the error buffers / reporters
into combinators in Context/ContextReporter.

Eventually, would like to statically know when we're in silent mode,
and only then use buffering (push buffering code down to BufferingReporter).

Simplify TryTwice; avoid capturing mutable var in closure.

Changed inSilentMode to no longer check `&& !reporter.hasErrors`;
disassembling optimized code showed that this was keeping the inliner
from inlining this method.

Introduce a couple more combinators:
 - withFreshErrorBuffer
 - propagatingErrorsTo
 - propagateImplicitTypeErrorsTo
Separate statistics from functional code; optimize.
Encapsulate creating SilentResultValue/SilentTypeError.

Do it consistently...