- isBoxedCaptured no longer requires the construction of intermediate capture sets.
 - isAlwaysEmpty is also true for solved variables that have no elements

 - Use a uniform criterion when to add them
 - Don't add them for @constructorOnly or @cc.untrackedCaptures arguments

@untrackedCaptures is a new annotation

 - Improve error messages
 - Better propagation of @uncheckedCaptures
 - -un-deprecacte caps.unsafeUnbox and friends.

We go back to the original lifetime restriction that box/unbox cannot
apply to universal capture sets, and drop the later restriction that
type variable instantiations may not deeply capture cap.

The original restriction is proven to be sound and is probably expressive
enough when we add reach capabilities.

This required some changes in tests and also in the standard library.

The original restriction is in place for source <= 3.2 and >= 3.5. Source
3.3 and 3.4 use the alternative restriction on type variable instances.

Some neg tests have not been brought forward to 3.4. They are all in
tests/neg-customargs/captures and start with

//> using options -source 3.4

We need to look at these tests one-by-one and analyze whether the new 3.5 behavior
is correct.

The previous scheme relied on subtle and unstated assumptions between
symbol updates and re-checking. If they were violated some definitions
could not be rechecked at all. The new scheme is more robust. We always
re-check except when the checker implementation returns true for `skipRecheck`.
And that test is based on an explicitly maintained set of completed symbols.

Enabled from 3.5.

There are still a number of open questions

 - Clarify type inference with existentials propagating into capture sets.
   Right now, no pos or run test exercises this.
 - Also map arguments of function to existentials (at least double flip ones).
 - Adapt reach capabilities and drop previous restrictions.

Fixes the problem in effect-swaps.scala

This gives us the necessary levers to switch to existential capabilities.

# Conflicts:
#	compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

An expandedUniversalSet was the same as `{cap}` but not reference-equal
to CaptureSet.universal. This construct was previously needed to avoid
multiple expansions, but this does not seem to be the case any longer so
the construct can be dropped.

# Conflicts:
#	compiler/src/dotty/tools/dotc/cc/Setup.scala

The encoding of (x: T) => U in capture checked code has changed.

Previously: T => U' { def apply(x: T): U }
Now: (T -> U' { def apply(x: T): U })^{cap}

We often handle dependent functions by transforming the apply method and then mapping
back to a function type using `.toFunctionType`. But that would always generate a
pure function, so the impurity info could get lost.

Still missing: Mapping parameters

Fixes crash with opaque types reported by @natsukagami

 - Add existentials to inferred types
 - Map existentials in one compared type to existentials in the other
 - Also: Don't re-analyze existentials in mapCap.

There was a forgotten case.

These should be no longer necessary with existentials.

A parameter accessor with a nonempty deep capture set needs to be tracked in refinements
even if it is pure, as long as it might contain captures that can be referenced using
a reach capability.

When we take `{elem} <: B ++ C` where `elem` is not yet included in `B ++ C`,
B is a constant and C is a variable, propagate with `{elem} <: C`.
Likewise if C is a constant and B is a variable.

This tries to minimize the slack between a union and its operands.

Note: Propagation does not happen very often in our test suite so far: Once in pos tests and
15 times in scala2-library-cc.

Don't treat user-defined capabilities deriving from caps.Capability as
maximal. That was a vestige from when we treated capability classes natively.
It caused code that should compile to fail because if `x extends Capability` then
`x` could not be widened to `x*`.

As a consequence we have one missed error in effect-swaps again, which re-establishes
the original (faulty) situation.

We might want to treat it specially since a RefiningVar should ideally be closed for
further additions when the constructor has been analyzed.

Use the syntactic sugar instead of expanding with capsOf

Add an option to avoid the type intersection when we do a select of a parameter
accessor that is mentioned in a class refinement type. It seems to give us a little
bit if performance, but nothing significant. So the option is off by default.

…ameters

The condition on capturing types did not make sense. In a type T^{} with an empty capture set
`T` can still be a type variable that's instantiated to a type with a capture set. Instead,
T^cs is always pure if T is always pure. For instance `List[T]^{p}` is always pure. That's
important in the context of the standard library, where such a type usually results from
an instantiation of a type variable such as `C[T]^{p}`.

Step1: refactor

The logic was querying the original types of trees, but we want the rechecked types instead.

Step 2: Change the logic. The previous one was unsound. The new logic is a bot too
conservative. I left comments in tests where it could be improved.

Make all operations final methods on Type or CaptureRef

Move extension methods on CaptureRef into CaptureRef itself or into CaptureOps

Previously, only asInstanceOf was excluded.

This reverts commit f1f5a05.

# Conflicts:
#	compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

Step 2: Change the logic. The previous one was unsound. The new logic is makes use of the
distinction between regular and unboxed parameters.

Fix the capture set computation of a type T @reachCapability where T
is not a singleton captureRef. Such types can be the results of typemaps.
The capture set in this case should be the deep capture set of T.

Drop the config option that enables it.

Also, fix Seq rechecking so that elements are always box adapted

Capability references in inlined code might end up not being tracked or being redundant.
Don't flag this as an error.

Give some explanation if an empty capture set was the result of an under-approximation.

Perform bounds checking before checking self types. Checking self types interpolates them,
which may give an upper approximation solution that failes subsequent bounds checks. On the
other hand, well-formedness checkimng should come after self types checking since otherwise
we get spurious "has empty capture set, cannot be tracked" messages.