The value of type Unit is `()`, using `Unit` usually also works because
it refers to the companion object of the class Unit, and because of
automatic `()` insertion when the expected type is `Unit`, but it's
still wrong. 2.13 marked it as `@compileTimeOnly` which is how I noticed.

This is easier to reason about, in particular because it avoids having
to think about what kind of classloader sbt decided to inflict upon us.
This fixes running the community-build test after switching to the 2.13
stdlib in the bootstrapped build.

This matches the behavior of Scala 2, this is necessary when using the
2.13 stdlib where scala.Serializable is a type alias of
java.lang.Serializable, otherwise the compiler will disallow extending
both Serializable and AnyVal.

This required some surgery in Build.scala: when compiling the
non-bootstrapped compiler, we need the 2.12 stdlib on the JVM and
compiler classpaths, because the current reference compiler cannot be
run using the 2.13 stdlib, on the other hand when _running_ the
non-bootstrapped compiler we need to the 2.13 stdlib on the compiler
classpath to produce a bootstrapped compiler that links against 2.13.

Upgrade the Scala 2 PickleFormat version to 5.2 (which is in fact
identical to 5.0).

Remove no longer needed -Ynew-collections flag and update the
related test files.

Replace getExternalDep and findLib by findArtifact, which is safer than
getLib was (it doesn't use `contains` to find the name which might yield
false positives).

See scala/scala#7896 and follow-up
scala/scala#7922, we can do both steps at once
since we always run with a bootstrapped dotty-library on the classpath, even
if the compiler itself is not bootstrapped.

These methods are now macros, so we always need to expand them.

We still need to support compiling it against the 2.12 stdlib until we
release a new reference compiler because the current reference compiler
cannot use the 2.13 stdlib. This is mostly not a problem, except that
this forces us to keep two versions of WeakHashSet, the same source file
cannot be used for both the 2.12 and 2.13 stdlib since `-=` and `+=` are
final in 2.13.

No cross-compilation needed since it's a bootstrapped-only project.

Also update it to master.

Needed to compile scala-xml with the 2.13 stdlib.

For the tests that were originally copied from scalac, I also copied the
updated version if one existed, or removed it if they had removed it.

Unfortunately, I also had to remove a bunch of Dotty tests that relied
on details of the 2.12 stdlib that I couldn't easily port to the 2.13
stdlib.

i3518 has to be disabled because using scala.Unit is marked @compileTimeOnly
and dotty crashes on @compileTimeOnly right now.

Static.mix(acc, this.productPrefix.hashCode()) in synthetic case class hash code updated to add parens.

This is necessary in particular to properly unpickle annotations with
default arguments, since default arguments have mangled names, this is
necessary to unpickle various parts of the 2.13 stdlib.

It's too hard to maintain it on top of the 2.13 stdlib, too bad because
it's proven to be a great torture test of the compiler.

Needed to get the productElementName.scala test to pass when using the
2.13 stdlib

We can't compile this test with the 2.13 stdlib, and the only codepath
it's supposed to exerce is currently dead code, I assume that the raw
Array that showed up there was due to some bug that has since been
fixed.

They're pickled with a class symbol, but we unpickled them as a type
aliases, which meant that the logic in REFINEDtpe wasn't able to
substitute `this` references correctly (there was even a comment
expressing puzzlement about this). Instead, unpickle them as
classes (TODO: add some logic in TreeChecker to make sure these symbols
are never referenced anywhere).

The REPL constructed a classloader containing the user classpath but
having the classloader used to run the REPL as a parent, meaning that
the scala-library we actually used came from the JVM classpath, so of
course everything exploded when using a repl compiled with the 2.12
stdlib and running with the 2.13 stdlib. Fixed by having
Rendering#classpath be constructed without any parent, just based on the
user classpath. This required some additional changes:

- We called ScalaRuntime#replStringOf using the ScalaRunTime class from
the scala-library used by the REPL, switch to calling it reflectively
through
- ReplDriver#withRedirectedOutput used `Console.withOut/Err` but that only
affects the Console object in the current classloader, not the one in
the user classloader, use `System.setOut/Err` instead (the class
`System` comes from the system classloader so there's only one of it).
- The macro tests now need to be run with the compiler on the user
classpath, this required some refactoring (This would be simpler to
handle if ReplTest didn't extend ReplDriver, but I'll let someone else
do that refactoring)

Applications#preTypeArgs can type arguments with an expected type like
`PartialFunction[Int, WildcardType]`, before this commit this was
rejected by `typedClosure` because it requires the expected type to be
fully-defined. Fixed by replacing the underdefined expected type by a
new one where the argument types come from the closure method type.

This is useful in particular to type `Map#collect` in 2.13 which is
overloaded.

`isMatchingApply(tp1)` compares the applied type `tp1` with `tp2`.
Before this commit, we called it recursively incorrectly by passing it a
type constructor instead of an applied type. The result was that it
returned false when it shouldn't. This lead to infinite loops in some
cases as demonstrated by tests/pos/factory-conversion.scala.

Note: even before this commit, the added test case used to compile, but
only when using a non-bootstrapped compiler. This puzzling behavior was
due to the logic in `monitoredIsSubType` detecting the loop and breaking
out of it before it lead to a stackoverflow. Of course this kind of
detection is fragile since it depends on the stack size as well as the
size of each stack frame, so we just happened to get lucky with the
non-bootstrapped compiler but not with the bootstrapped one. As always,
when debugging subtyping issues, it's a good idea to run the compiler
with `-Yno-deep-subtypes` to replace the recovery logic in
`monitoredIsSubType` by an immediate crash.

Otherwise we'll run it with the non-bootstrapped compiler which can only
work by chance.

SeqFactory changed package, since we never actually complete the symbol,
this did not lead to a runtime error since we ended up creating a stub
symbol for it.

In Tasty, pickling a selection will pickle its signature using the
SIGNED tag to be able to distinguish overloads, this usually works but
it turns out that some overloads have the same signature (see
tests/pos/poly-signature.scala, but this also affects `Set#++` in the
2.13 collections), resulting in ambiguous overload errors when
unpickled.

This commit solves this problem by also storing the number of type
parameters in the signature. The obvious way to implement this would be
to add a field of type Int to the `Signature` case class, but that
wouldn't scale to a future where methods may have multiple type
parameter lists, so instead we change the existing `paramsSig:
List[TypeName]` field to take a list of `TypeName | Int`.

tests/pos/javaReadsSigs/fromjava.java still imported old collections

doc-tool/test/dotty/tools/dottydoc/WhitelistedStdLib.scala and GenCollections depended on the removed scala 2 library

This is necessary for the community build to work on the CI now that we
run the community build with fork in Test set to true.

And use this version as an indicator of 2.13 support, to allow sbt-dotty
to work with nightly builds of 0.18 from both before and after the
switch to 2.13.

To be used as a reference compiler in this PR so that we do not need to
keep our codebase compatible with both the 2.12 and 2.13 stdlib which
prevents us from fixing many deprecation warnings properly.

- also updated drone.yml to remove nightly publishing

This is possible now that all deprecation warnings are fixed.

If we don't set "-classpath" explicily the default will be "-classpath
.", this resulted in test failures due to "." containing the output of
previous tests.

Further work to present a nicer API for Signature might be needed.

productElementName is no longer generated in Desugar after the previous
commit.

It doesn't output an error anymore for some reason, but that's fine: we
only care about it not crashing the compiler, which is what fuzzy tests
check.

This fixes a pickling/unpickling difference in sip23-valueof.scala and
makes sense in general.

Needs to be replaced by something that doesn't use the parallel
collections, I attempted to do so in
b9ba16e but the result caused
deadlocks, don't have time to investigate right now.

I accidentally replaced `"` by `'` in the generated .dotty-ide.json file
in 2ae438d which broke everything.

We now need to dealias deeply to get tests/run/Course-2002-13.scala and
tests/run/enrich-gentraversable.scala to pass.

`membersBasedOnFlags` internally uses `memberNames` which returns a Set,
so the order of its elements is unstable. We were using it when
generating static forwarder methods which lead to some idempotency tests
failing (no idea why this didn't manifest itself before). Fixed by
adding a new `sortedMembersBasedOnFlags` which sorts members by names
and signatures (this required adding a somewhat arbitrary lexicographic
ordering to Signature).

So far, Jar was defined as an Iterable implementation that overrides
`foreach` and then define `override def iterator = this.toList.iterator`
That was OK with the 2.12 stdlib, but stackoverflows with the 2.13 one
due to `toList` now being implemented in terms of `iterator`.

Any way, it turns out that we don't really need Jar to be an Iterable,
so the simplest fix was to just remove these methods, and add back a
`toList` for the one usesite that needed it (not very efficient, but not
any worse than before).

Not needed with 2.13 where CanBuildFrom is mostly gone.

Originally fixed in f8a746e, lost in
b9ba16e when tests were updated based
on their version in scala/scala.

To pick up the improvements since the previous one.

And the revert the CI changes from the previous commit which are no
longer needed.