SI-7928 Favour module accessors symbols in rebind

The Refchecks tree transformer transforms a nested modules that
overrides a method into a pair of symbols: the module itself, and
an module accessor that matches the overridden symbol.

    [[syntax trees at end of                     typer]] // test1.scala
    package <empty> {
      abstract trait C2 extends scala.AnyRef {
        def O1: Any
      };
      class C1 extends AnyRef with C2 {
        object O1 extends scala.AnyRef
      }
    }

    [[syntax trees at end of                 refchecks]] // test1.scala
    package <empty> {
      abstract trait C2 extends scala.AnyRef {
        def O1: Any
      };
      class C1 extends AnyRef with C2 {
        object O1 extends scala.AnyRef
        @volatile <synthetic> private[this] var O1$module: C1.this.O1.type = _;
        <stable> def O1: C1.this.O1.type = {
          C1.this.O1$module = new C1.this.O1.type();
          C1.this.O1$module
        }
      }
    }

When constructing a TypeRef or SingleType with a prefix and and a symbol,
the factory methods internally use `rebind` to see if the provided symbol
should be replaced with an overriding symbol that is available in that prefix.

Trying this out in the REPL is a bit misleading, because even if you change
phase to `refchecks`, you won't get the desired results because the transform
is not done in an InfoTransformer.

   scala> val O1 = typeOf[C1].decl(TermName("O1"))
   O1: $r.intp.global.Symbol = object O1

   scala> typeRef(typeOf[C2], O1, Nil)
   res13: $r.intp.global.Type = C2#O1

   scala> res13.asInstanceOf[TypeRef].sym.owner
   res14: $r.intp.global.Symbol = class C1

But debugging the test case, we get into `rebind` during an AsSeenFrom
which is where we crashed when `suchThat` encountered the overloaded
module and module accessor symbols:

    typeOf[OuterObject.Inner.type].memberType(symbolOf[InnerTrait.Collection])
      ...
      singleTypeAsSeen(OuterTrait.this.Inner.type)
        val SingleType(pre, sym) = tp
        // pre = OuterTrait.this.type
        // sym = OuterTrait.Inner

        val pre1 = this(pre) // OuterObject.type

        singleType(pre1, sym)
          rebind(pre1, sym)  // was crashing, now OuterObject.Inner
      }

This commit excludes the module symbol from symbol lookup in the prefix in rebind.
More clear implicitNotFound error for ExecutionContext
Merge pull request #3079 from jamesward/fix/ec-implicit-error

More clear implicitNotFound error for ExecutionContext
Merge pull request #3073 from retronym/ticket/7928

 Favour module accessors symbols in rebind
Remove empty check files and flags files.

    for f in $(find test -name '*.check' -o -name '*.flags'); do [[ $(wc -c $f | sed -E 's/ *([0-9]+).*/\1/') == "0" ]] && rm $f; done
Remove orphaned check files and flags files.

    (for f in $(find test -name '*.check' -o -name '*.flags'); do bare=$(echo $f | sed -E 's/\.\w+$//'); ([[ -f "$bare" ]] || [[ -d "$bare" ]] || [[ -f "$bare.scala" ]] || [[ -f "$bare.test" ]] || echo $f) done;) | xargs rm
Merge pull request #3080 from retronym/topic/empty-check

Check file maintainence