Remove some old, obsolete & untested hacks from ExplicitOuter.
Added a test for one of them to show this is now fine.

There are a lot of `makeNotPrivate` invocations sprinkled around
the codebase. Lets see if we can centralize the ones dealing
with trait methods that need implementations in the phase that emits them.

For example Fields (accessors for fields/modules) or SuperAccessors.

... instead of emitting ValDefs and field symbols, which are then
promptly unlinked and transformed by the "late trait methods"
logic in mixins...

Mixins still synthesizes implementations for these accessors
in subclasses.

A paramaccessor in a trait is a method without an underlying field.

Remove weird special cases for private-local fields
and parameter accessor (fields).

One change with the new trait val encoding:

```
scala>  trait T { private[this] var x: String = "1" ; def x(): Int = 1 }
<console>:11: error: method x is defined twice;
  the conflicting variable x was defined at line 11:37
        trait T { private[this] var x: String = "1" ; def x(): Int = 1 }
                                                          ^
```

Whereas:

```
scala>  class T { private[this] var x: String = "1" ; def x(): Int = 1 }
defined class T
```

Before, both the `class` and `trait` definition were accepted.
(Because there is no accessor for a private[this] val/var,
and a MethodType does not match the type of a value.)

(Dotty accepts neither the class or the trait definition.)

Discovered by scala-js's test suite.

Clone at uncurry to preserve it in its info history.
Discovered by the scala-js test suite.

There's no other place to squirrel away the annotation
until we create a field in a subclass.

The test documents the idea, but does not capture the
regression seen in the wild, as explained in a comment.

Derive/filter/propagate annotations in info transformer,
don't rely on having type checked the derived trees in order
to see the annotations.

Use synthetics mechanism for bean accessors -- the others
will soon follow.

Propagate inferred tpt from valdef to accessors
by setting type in right spot of synthetic tree
during the info completer.

No need to add trees in derivedTrees, and get rid of
some overfactoring in method synthesis, now that we have
joined symbol and tree creation.

Preserve symbol order because tests are sensitive to it.

Drop warning on potentially discarded annotations,
I don't think this warrants a warning.

Motivated by breaking the scala-js compiler, which relied
on annotations appearing when trees are type checked.
Now that ordering constraint is gone in the new encoding,
we may as well finally fix annotation assignment.

No longer making trait methods not-protected.
(The backend only does public/private because of the poor
mapping between visibility from Scala to the JVM).

Note that protected trait members will not receive static forwarders
in module classes (when mixed into objects).

Historic note: we used to `makeNotPrivate` during explicitouter,
now we do it later, which means more private methods must be excluded
(e.g., lambdaLIFTED ones).