Revert #3735: Allow accesses to private package members from nested

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 #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.

Author: odersky

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -746,9 +746,7 @@ object SymDenotations {
              (  !(this is Local)
              || (owner is ImplClass) // allow private local accesses to impl class members
              || isCorrectThisType(pre)
-             ) &&
-             (!(this.is(Private) && owner.is(Package)) ||
-              owner == ctx.owner.enclosingPackageClass)
+             )
         || (this is Protected) &&
              (  superAccess
              || pre.isInstanceOf[ThisType]

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

@@ -204,27 +204,17 @@ trait TypeAssigner {
             var packageAccess = false
             val what = alts match {
               case Nil =>
-                i"$name cannot be accessed as a member of $pre"
+                name.toString
               case sym :: Nil =>
-                if (sym.owner.is(Package)) {
-                  packageAccess = true
-                  i"${sym.showLocated} cannot be accessed"
-                }
-                else {
-                  val symStr = if (sym.owner == pre.typeSymbol) sym.show else sym.showLocated
-                  i"$symStr cannot be accessed as a member of $pre"
-                }
+                if (sym.owner == pre.typeSymbol) sym.show else sym.showLocated
               case _ =>
-                em"none of the overloaded alternatives named $name can be accessed as members of $pre"
+                em"none of the overloaded alternatives named $name"
             }
-            val where =
-              if (!ctx.owner.exists) ""
-              else if (packageAccess) i" from nested ${ctx.owner.enclosingPackageClass}"
-              else i" from ${ctx.owner.enclosingClass}"
+            val where = if (ctx.owner.exists) s" from ${ctx.owner.enclosingClass}" else ""
             val whyNot = new StringBuffer
             alts foreach (_.isAccessibleFrom(pre, superAccess, whyNot))
             if (tpe.isError) tpe
-            else errorType(ex"$what$where.$whyNot", pos)
+            else errorType(ex"$what cannot be accessed as a member of $pre$where.$whyNot", pos)
           }
         }
         else ctx.makePackageObjPrefixExplicit(tpe withDenot d)

tests/neg/i3339.scala

@@ -0,0 +1 @@
+A

tests/run/i3339.check

@@ -0,0 +1,17 @@
+package outer {
+  private class A() {
+    override def toString = "A"
+  }
+
+  package inner {
+    object Test {
+      def main(args: Array[String]): Unit = {
+        println(new A())  // now ok
+      }
+    }
+  }
+}
+
+object Test extends App {
+  outer.inner.Test.main(Array())
+}