Inferring tracked

[KacperFKorban]

Infer tracked for parameters that are referenced in the public signatures of the defining class.
e.g.

class OrdSet(val ord: Ordering) {
  type Set = List[ord.T]
  def empty: Set = Nil

  implicit class helper(s: Set) {
    def add(x: ord.T): Set = x :: remove(x)
    def remove(x: ord.T): Set = s.filter(e => ord.compare(x, e) != 0)
    def member(x: ord.T): Boolean = s.exists(e => ord.compare(x, e) == 0)
  }
}

In the example above, ord is referenced in the signatures of the public members of OrdSet, so a tracked modifier will be inserted automatically.

Aldo generalize the condition for infering tracked for context bounds. Explicit using val witnesses will now also be tracked by default.

This implementation should be safe with regards to not introducing spurious cyclic reference errors.
Current limitations (I'll create separate issues for them, once this is merged):

• Inferring tracked for given classes is done after the desugaring to class + def, so the def doesn't know about tracked being set on the original constructor parameter. This might be worked around by watching the original symbol or adding an attachment pointer to the implicit wrapper.

  given mInst: (c: C) => M:
  def foo: c.T = c.foo

• Passing parameters as an inferred tracked arguments in parents doesn't work, since forcing a parent (term) isn't safe.
  This can be replaced with a lint that is checked after Namer.

[KacperFKorban]

Test logs for after enabling a subset of modularity required for tracked: https://github.com/scala/scala3/actions/runs/11557079836/job/32166261964

[mbovel]

I only have few comments about cosmetic and naming.

Otherwise looks very good to me; the diff is small and the changes are clear.

The heuristics for determining if tracked should be added look good to me at first sight, but I haven't experimented extensively with it.