Move a test from pos to run to highlight bytecode deficiencies.

We'll address them in subsequent commits.
SI-6666 Account for nesting in setting INCONSTRUCTOR

This flag is calcualed in Namers, and assigned to class
and module class symbols that are defined in self/super-calls,
and in early definitions.

For example, class D is INCONSTRUCTOR in each case below:

    class C extends Super({class D; ()})
    class C(a: Any) {
      def this(a: Any) = this({class D; ()})
    }
    new { val x = { class D; () } with Super(())

But, the calculation of this flag failed to account for
nesting, so it was not set in cases like:

    class C(a: Any) {
      def this(a: Any) = this({val x = {class D; ()}; x})
    }

This patch searches the enclosing context chain, rather than
just the immediate context. The search is terminated at the
first non term-owned context. In the following example, this
avoids marking `E` as INCONSTRUCTOR; only `D` should be.

    class C extends Super({class D { class E }; ()})

This closes SI-6259 and SI-6506, and fixes one problem
in the recently reopened SI-6957.
Add a test case from the comments of SI-6666.

This one lands in the new implementation restriction
which beats the VerifyError.
Broader checks for poisonous this references.

Replaces more VerifyErrors with implementation restrictions.
SI-6666 Catch VerifyErrors in the making in early defs.

As we did for self/super calls, add a backstop into
explicitouter and lambdalift to check when we try to
get an outer pointer to an under-construction instance.
Class symbols can't be contravariant.

During development of the fix for SI-6666, I encountered:

    % test/files/pos/t4842.scala
    test/files/pos/t4842.scala:10: error: contravariant class Bar occurs in covariant position in type ()this.Bar of constructor Bar
         this(new { class Bar { println(Bar.this); new { println(Bar.this) } }; new Bar } ) // okay

I had incorrectly set the INCONSTRUCTOR flag on the class symbol
`Bar`. (It isn't directly in the self constructor call, as it
is nested an intervening anonymous class.)

But, this flag shares a slot with CONTRAVARIANT, and the variance
validation intepreted it as such.

ClassSymbol already has this code to resolve the ambiguous
flags for display purposes:

    override def resolveOverloadedFlag(flag: Long) = flag match {
      case INCONSTRUCTOR => "<inconstructor>" // INCONSTRUCTOR / CONTRAVARIANT / LABEL
      case EXISTENTIAL   => "<existential>"   // EXISTENTIAL / MIXEDIN
      case IMPLCLASS     => "<implclass>"     // IMPLCLASS / PRESUPER
      case _             => super.resolveOverloadedFlag(flag)
    }

This commit overrides `isContravariant` to reflect the same logic.
Merge pull request #2017 from retronym/ticket/6666

Booking more progress on SI-6666