SI-8219 Pending test case for unpositioned implicit error

Extracted with tweezers from ScalaTest and Scalacheck implicits.

    % scalac-hash v2.11.0-M7 test/pending/pos/t8219.scala
    error: type mismatch;
     found   : Any
     required: AnyRef
    Note: Any is not implicitly converted to AnyRef.  You can safely
    pattern match `x: AnyRef` or cast `x.asInstanceOf[AnyRef]` to do so.
    error: type mismatch;
     found   : Any
     required: AnyRef
    Note: Any is not implicitly converted to AnyRef.  You can safely
    pattern match `x: AnyRef` or cast `x.asInstanceOf[AnyRef]` to do so.
    two errors found
SI-8219 Pending test to show suspicous overload in == in AnyRef

    % scalac-hash v2.11.0-M7 test/pending/neg/t8219-any-any-ref-equals.scala
    test/pending/neg/t8219-any-any-ref-equals.scala:5: error: overloaded method value == with alternatives:
      (x$1: AnyRef)Boolean <and>
      (x$1: Any)Boolean
     does not take type parameters
      "".==[Int]
         ^
    one error found

Usually for Java-originated methods, we are allow Object and Any
to unify pre-erasure in method signatures. This is handled in
`matchesParams`, and is predicated on whether the method type is
an instance of `JavaMethodType`

For instance, we are allowed to:

    scala> class C { override def equals(a: Any) = false }
    defined class C

On account of:

    scala> typeOf[Object].decl(nme.equals_).info.getClass
    res7: Class[_ <: $r.intp.global.Type] = class scala.reflect.internal.Types$JavaMethodType

But:

    scala> typeOf[Object].decl(nme.EQ).defString
    res8: String = final def ==(x$1: AnyRef): Boolean

    scala> typeOf[Object].decl(nme.EQ).info.getClass
    res9: Class[_ <: $r.intp.global.Type] = class scala.reflect.internal.Types$MethodType

More special casing is probably needed.
SI-8129 Make Object#== override Any#==

And the same for !=

If we tried to declare these signatures in non-fictional classes,
we would be chastised about collapsing into the "same signature after
erasure".

This will have an influence of typing, as the typechecking of
arguments is sensitive to overloading: if multiple variants are
feasible, the argument will be typechecked with a wildcard expected
type. So people inspecting the types of the arguments to `==` before
this change might have seen an interesting type for
`if (true) x else y`, but now the `If` will have type `Any`, as we
don't need to calculate the LUB.

I've left a TODO to note that we should really make `Any#{==, !=}`
non-final and include a final override in `AnyVal`. But I don't think
that is particularly urgent.
SI-8129 Crack the case of the curiously incoherent Context

 - Typer is created with Context.
 - Typer creates an Inferencer with said Context.
 - Typer mutates Typer#context after each import statement
 - Typer mutates its current Context (e.g to disable implicits.)
 - Typer asks a question of Inferencer
 - Inferencer, looking at the old context, thinks that implicits
   are allowed
 - Inferencer saves implicit ambiguities into the wrong Context.

Because of this bug, overload resolution in blocks or template
bodies for applications that follow an import have been
considering implicit coercions in the first try at static overload
resolution, and, in the rare case that it encounters an ambigous
implicit in the process, leaking an unpositioned ambiguout error.

This commit ensures coherency between `typer.context` and
`typer.infer.context` by making the latter delegate to the former.
Merge pull request #3497 from adriaanm/rebase-3464

 Make Object#== override Any#==