Previously, `given ()`  was legal, but it serves no purpose and only complicates things.

Parser.syntaxError contains a tweak that underlines the whole span
of the current token, if it has a name. Tho make this work reliably
we need to reset the name to null when reading a new token, since not every
token sets a name.

It's `given A => B` instead of `A |=> B`.

# Conflicts:
#	tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TastyInterpreter.scala
#	tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala

Also: drop some doc pages that are no longer used.

Implied felt forced in this context

Token: INSTANCE -> IMPLIED
Flag: Contextual -> Given

It's now src$package instead of src#object

Have tests for other sorts of definitions

AN old-style package object of package `p` printed `package object p`.
Since there are now several possible toplevel source files, we can't
do the same for toplevel source file. I am not yet quite sure what to
do instead. For the moment, we just print the name of the generated object.

Detect and report double definitions between members of different toplevel files.
This required a fix in method `precedesIn` for the case where neither owner is
part of the checked baseclass sequence. In that case the answer should be `false`
but we reported `true`.

Test that an error message is issued for sources in different directories
but with the same filename and package.

Also: Drop out-of-date ErrorMessageTest

and fix test comment

 - There might be several overloaded variants
 - There might be members with the same name that are not modules.
   These should be left alone.

Previously, package-object local definitions won over global
ones. It's more systematic to form the union of both.

Also, absent dummy modules or classes have to be ignored in order
not to poison the union.

These changes would have made sense also for old-style package objects, btw.

This is the only way that avoids tricky special cases.

Also: Fix desugaring of toplevel definitions so that imports are
visible in wrapper objects.

Doing it while desugaring does not always work since definitions
might already have been indexed before desugaring happens, in which
case the symbol gets duplicated. We do the widening in Namer instead.

Test case is i3339. In
```
package outer {
  private class A() {
    override def toString = "A"
  }

  package inner {
    object Test {
      def main(args: Array[String]): Unit = {
        println(new A()) // allow access?
      }
    }
  }
}
```
should the access to private class `A` from a nested package be allowed?
The usual rules for Scala say yes, since the access is from a nested scope.
We changed this to in scala#3735 to "no", since we wanted to emulate Java's default
package-private visibility. But this is unsystematic for two reasons:

 - it breaks the universal meaning of `private` in Scala
 - it uses a different name (i.e. private) for what is not named
   in Java at all, and is named `internal` in Kotlin.
 - it does not generalize to members of classes which could
   also profit from a Java-package-private visibility specifier.

I believe it is better to leave `private` as it is, and, if we want to
emulate `internal` (which might be a good idea), introduce a new modifier
for it.

Don't leave out package prefixes under homogenizedView. We want to see
them to make sure they are inserted in the same way before and after pickling.

This discovered a problem in unpickler where package object prefixes were not
correctly inserted back. Test case is pickleAlias.scala.

Change scheme how sourcenames are computed from filenames to account for filenames
that have additional `.`s in them. Fix comments.