Trial: Make implicit resolution block scoped

So far, nesting was just one of several criteria for selecting
a best implicit. What would happen if nesting was most significant?
I.e. inner implicits would always win over outer ones? This has the
potential to simplify the rules, gain effiviency, and solve the
local consistency problem since we can disambiguate implicits using
a local definition (see implicit-disambiguation.scala as a test case).

Author: odersky

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -1148,6 +1148,7 @@ trait Implicits { self: Typer =>
        */
       def compareCandidate(prev: SearchSuccess, ref: TermRef, level: Int): Int =
         if (prev.ref eq ref) 0
+        else if (prev.level != level) prev.level - level
         else nestedContext().test(implicit ctx => compare(prev.ref, ref, prev.level, level))
 
       /** If `alt1` is also a search success, try to disambiguate as follows:

tests/run/implicit-disambiguation.check

@@ -0,0 +1 @@
+B

tests/run/implicit-disambiguation.scala

@@ -0,0 +1,20 @@
+abstract class A {
+  def show: String
+}
+class B extends A {
+  def show = "B"
+}
+class C extends A {
+  def show = "C"
+}
+object M {
+  def f given B, C : String = {
+    implied a for A = infer[B]
+    infer[A].show
+  }
+}
+object Test extends App {
+  implied b for B
+  implied c for C
+  println(M.f)
+}