Make more explicit that TypeError is being thrown.

`typer.TyperErrorGen.MacroCantExpandIncompatibleMacrosError`
throws because the type checker it uses is at `NoContext`,
which throws by default... This default is bad and is going to change,
so make this code independent of that future sanity.

TODO: don't use mutable state to determine position for the error
wip: reduce Context's error reporting surface

all error reporting should eventually go through
context.reportBuffer (which I'd rename to context.reporter)
no forwards allowed in Context (or anywhere else)
untangle ambiguous errors

now that all reporting mode manipulators are private to Context,
let's untangle this mess:
  - every setReportErrors gets a corresponding setAmbiguousErrors(true)
  - every setBufferErrors gets a corresponding setAmbiguousErrors(false)
  - every setThrowErrors  gets a corresponding setAmbiguousErrors(false)

doing this to eventually get to a strategy-based approach to reporting,
where the reporting mode is captured in the reporter being used,
with as little mutation as possible to capture more invariants
(would like to stop throwing TypeError eventually and only have two modes:
buffering reporter, regular reporter)
wip: towards different ReportBuffers

The only thing that changes somewhat often in ReportBuffer
behavior is whether to buffer or not.
ThrowErrors is constant throughout a phase, so let's use a different
ReportBuffer for that, and eliminate branching.

buffer errors in all Context#error overloads
--> this seems like the right thing to do
except for two shady neg tests, the test suite passes

the failures are caused by the buffered error masking the more verbose one

/localhome/jenkins/a/workspace/scala-checkin-manual/build-ant-macros.xml:762: Test suite finished with 2 cases failing:
fail - neg/macro-basic-mamdmi  [output differs]% scalac macro-basic-mamdmi/Impls_Macros_Test_1.scala
Impls_Macros_Test_1.scala:33: error: macro implementation not found: foo
(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)
  println(foo(2) + Macros.bar(2) * new Macros().quux(4))
             ^
Impls_Macros_Test_1.scala:33: error: macro implementation not found: bar
(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)
  println(foo(2) + Macros.bar(2) * new Macros().quux(4))
                             ^
Impls_Macros_Test_1.scala:33: error: macro implementation not found: quux
(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)
  println(foo(2) + Macros.bar(2) * new Macros().quux(4))
                                                    ^
three errors found

% diff /localhome/jenkins/a/workspace/scala-checkin-manual/test/files/neg/macro-basic-mamdmi-neg.log /localhome/jenkins/a/workspace/scala-checkin-manual/test/files/neg/macro-basic-mamdmi.check
@@ -1,13 +1,5 @@
-Impls_Macros_Test_1.scala:33: error: macro implementation not found: foo
-(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)
-  println(foo(2) + Macros.bar(2) * new Macros().quux(4))
-             ^
-Impls_Macros_Test_1.scala:33: error: macro implementation not found: bar
-(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)
-  println(foo(2) + Macros.bar(2) * new Macros().quux(4))
-                             ^
 Impls_Macros_Test_1.scala:33: error: macro implementation not found: quux
 (the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them)
   println(foo(2) + Macros.bar(2) * new Macros().quux(4))
                                                     ^
-three errors found
+one error found

fail - neg/interop_typetags_without_classtags_arenot_manifests.scala  [output differs]% scalac interop_typetags_without_classtags_arenot_manifests.scala
interop_typetags_without_classtags_arenot_manifests.scala:6: error: No Manifest available for T.
    println(manifest[T])
                    ^
one error found

% diff /localhome/jenkins/a/workspace/scala-checkin-manual/test/files/neg/interop_typetags_without_classtags_arenot_manifests-neg.log /localhome/jenkins/a/workspace/scala-checkin-manual/test/files/neg/interop_typetags_without_classtags_arenot_manifests.check
@@ -1,4 +1,6 @@
-interop_typetags_without_classtags_arenot_manifests.scala:6: error: No Manifest available for T.
+interop_typetags_without_classtags_arenot_manifests.scala:6: error: to create a manifest here, it is necessary to interoperate with the type tag `evidence$1` in scope.
+however typetag -> manifest conversion requires a class tag for the corresponding type to be present.
+to proceed add a class tag to the type `T` (e.g. by introducing a context bound) and recompile.
     println(manifest[T])
                     ^
 one error found
throwing reporter
remove context.error/throwable overload
wip: set ctxReporter once for checking/throwing