SI-8695  SeqLike has unintuitive implementation of combinations

Clarified what `combinations` means in the docs.
SI-8754  linear seqs aren't

LinearSeqLike still isn't exactly linear (LinearSeqOptimized is), but at least the docs now give reasonably correct information about what is actually going on.
Update ScalaDoc code examples not to use deprecated constructs

- Replace newTermName in favour of TermName
- Replace newTypeName in favour of TypeName
SI-8502 Improve resiliance to absent packages

When unpickling a class, we create stub symbols for references
to classes absent from the current classpath. If these references
only appear in method signatures that aren't called, we can
proceed with compilation. This is in line with javac.

We're getting better at this, but there are still some gaps.
This bug is about the behaviour when a package is completely
missing, rather than just a single class within that package.

To make this work we have to add two special cases to the unpickler:

  - When unpickling a `ThisType`, convert a `StubTermSymbol` into
    a `StubTypeSymbol`. We hit this when unpickling
    `ThisType(missingPackage)`.
  - When unpickling a reference to `<owner>.name` where `<owner>`
    is a stub symbol, don't call info on that owner, but rather
    allow the enclosing code in `readSymbol` fall through to
    create a stub for the member.

The test case was distilled from an a problem that a Spray user
encountered when Akka was missing from the classpath.

Two existing test cases have progressed, and the checkfiles are
accordingly updated.
Merge pull request #4112 from retronym/ticket/8502

SI-8502 Improve resiliance to absent packages
Merge pull request #4149 from Ichoran/issue/8754

SI-8754  linear seqs aren't
add 0X... for hex number literal
add 0X...hex number literal in syntax summary
SI:7988 - scala.collection.JavaConverters spelling mistake

Fixed typo and cleaned up the grammar in the paragraph
SI-8995: Fix broken link in error message

Change broken link to scala-xml documentation by pointing instead to
scala-xml project.
Remove commented-out debugging code in PriorityQueue
Remove completely commented-out test/run file
Merge pull request #4172 from advancedxy/spec-fix

add 0X... for hex number literal
Merge pull request #4143 from Ichoran/issue/8695

SI-8695  SeqLike has unintuitive implementation of combinations
Merge pull request #4173 from kanielc/SI-7988

SI-7988 - scala.collection.JavaConverters spelling mistake
Merge pull request #4179 from gdickinson/remove_commented_priorityqueue_code

Remove commented priorityqueue code
Merge pull request #4166 from lpiepiora/update-scaladoc-examples

Update ScalaDoc code examples not to use deprecated constructs
Merge pull request #4174 from kanielc/SI-8995

SI-8995: Fix broken link in error message
SI-9018 Fix regression: cycle in LUBs

Regressed in 4412a92d, which admirably sought to impose some structure
on the domain of depths, but failed to preserve an imporatnt part of
said structure.

When calculating LUBs and GLBs, the recursion depth is limited by
propagating a decreasing depth parameter. Its initial value is
the recursion limit, and is calcluated from the maximum depth of
the types fed into the calculation.

Here are a few examples that give a flavour of this calculation:

```
scala> class M[A]
defined class M

scala> class N extends M[M[M[M[A]]]]
<console>:34: error: not found: type A
       class N extends M[M[M[M[A]]]]
                               ^

scala> class N extends M[M[M[M[Int]]]]
defined class N

scala> lubDepth(typeOf[N] :: Nil)
res5: scala.reflect.internal.Depth = Depth(4)

scala> type T = M[Int] with M[M[Int]]
defined type alias T

scala> lubDepth(typeOf[T] :: Nil)
res7: scala.reflect.internal.Depth = Depth(3)
```

One parts of the LUB calculation, `lub0`, truncates the lub to
`Any` when the depth dives below zero.

Before 4412a92d:

    ------------------
    value  decr   incr
    ------------------
       -3    -3     -2 (= AnyDepth)
       -2    -3     -1
       -1    -2      0
        0    -1      1
        1     0      2
        ...

After 4412a92d:

    -----------------------
    value      decr    incr
    -----------------------
    -MaxInt -MaxInt -MaxInt (= AnyDepth)
          0 -MaxInt       1
          1       0       2
          ...

The crucial difference that triggered the regression is that
decrementing a depth of zero now goes to the sentinel value,
`AnyDepth`, rather than to `-1`.

This commit modifies `Depth` to allow it to represent any negative
depth. It also switches the sentinel value for `AnyDepth`. Even
though I don't believe it is needed, I have also allowed for
`Depth.Zero.decr.decr.decr == Depth.AnyVal`, which was historically
the case in 2.10.4.

To better understand what was happening, I added tracing to the
calculation and diffed the before and after:

  https://gist.github.com/retronym/ec59608eecc52bb497fa

Notice that when `elimSub(ts, depth = 0)` recursively calls `lub`,
it does so with the variant that caluculates the allowable depth
from the shape of the given types. We can then infinitely recurse.

Before 4412a92d:
```
|-- elimSub(depth = 0, ts = List(Comparable[_ >: TestObject.E.Value with String <: Comparable[_ >: TestObject.E.Valu
|   |-- lub(depth = -1, ts = List(TestObject.E.Value with String, TestObject.C))
|   |   |-- lub0(depth = -1, ts0 = List(TestObject.E.Value with String, TestObject.C))
|   |   |   |-- elimSub(depth = -1, ts = List(TestObject.E.Value with String, TestObject.C))
|   |   |   |== List(TestObject.E.Value with String, TestObject.C)
|   |   |   |-- Truncating LUB to
|   |   |   |== Any
|   |   |== Any
|   |== Any
|== List(Comparable[_ >: TestObject.E.Value with String <: Comparable[_ >: TestObject.E.Value with String <: java.io
|-- lub(depth = 0, ts = List(java.lang.type, java.lang.type))
|   |-- lub0(depth = 0, ts0 = List(java.lang.type, java.lang.type))
|   |   |-- elimSub(depth = 0, ts = List(java.lang.type, java.lang.type))
|   |   |== List(java.lang.type)
|   |== java.lang.type
|== java.lang.type
|-- elimSub(depth = 0, ts = List(Object, Object))
|== List(Object)
|-- elimSub(depth = 0, ts = List(Any, Any))
|== List(Any)
```

After 4412a92d:

```
|-- elimSub(depth = 0, ts = List(Comparable[_ >: TestObject.E.Value with String <: Comparable[_ >: TestObject.E.Valu
|   |-- lub(depth = _, ts = List(TestObject.E.Value with String, TestObject.C))
|   |   |-- lub(depth = 3, ts = List(TestObject.E.Value with String, TestObject.C))
|   |   |   |-- lub0(depth = 3, ts0 = List(TestObject.E.Value with String, TestObject.C))
|   |   |   |   |-- elimSub(depth = 3, ts = List(TestObject.E.Value with String, TestObject.C))
|   |   |   |   |== List(TestObject.E.Value with String, TestObject.C)
|   |   |   |   |-- lub1(depth = 3, ts = List(TestObject.E.Value with String, TestObject.C))
|   |   |   |   |   |-- elimSub(depth = 3, ts = List(scala.math.Ordered[TestObject.E.Value], scala.math.Orde
|   |   |   |   |   |== List(scala.math.Ordered[TestObject.E.Value], scala.math.Ordered[TestObject.C])
```
Merge pull request #4178 from retronym/ticket/9018

SI-9018 Fix regression: cycle in LUBs