Update doc page

Author: odersky

docs/_docs/reference/experimental/modularity.md

@@ -116,25 +116,22 @@ ClsParam  ::=  {Annotation} [{Modifier | ‘tracked’} (‘val’ | ‘var’)]
 
 The (soft) `tracked` modifier is only allowed for `val` parameters of classes.
 
-### Tracked inference
+### Tracked Inference
 
-In some cases `tracked` can be infered and doesn't have to be written
-explicitly. A common such case is when a class parameter is referenced in the
-signatures of the public members of the class. e.g.
-```scala 3
-class OrdSet(val ord: Ordering) {
-  type Set = List[ord.T]
-  def empty: Set = Nil
+In some common cases the tracked modifier can be inferred, so it does not
+need to be written explicitly. Specifically, we infer `tracked` for a `val`
+parameter of a class if the formal parameter's type defines an abstract type member.
+This means that we do not lose information about how that member
+is defined in the actual argument passed to the class constructor.
 
-  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)
-  }
-}
+For instance, tracked `would` be inferred for the `SetFunctor` class
+we defined before, so we can also write it like this:
+```scala
+class SetFunctor(val ord: Ordering):
+  type Set = List[ord.T]
+  ...
 ```
-In the example above, `ord` is referenced in the signatures of the public
-members of `OrdSet`, so a `tracked` modifier will be inserted automatically.
+The `tracked` modifier on the `ord` parameter is inferred here, since `ord` is of type `Ordering`, which defines an abstract type member `T`.
 
 Another common case is when a context bound has an associated type (i.e. an abstract type member) e.g.
 ```scala 3
@@ -145,7 +142,7 @@ trait TC:
 class Klass[A: {TC as tc}]
 ```
 
-Here, `tc` is a context bound with an associated type `T`, so `tracked` will be inferred for `tc`.
+Here, `tc` is a context bound with an associated type `T`, so `tracked val` will be inferred for `tc` and the parameter will be represented as a field.
 
 ### Discussion
 
@@ -160,10 +157,10 @@ If we assume `tracked` for parameter `x` (which is implicitly a `val`),
 then `foo` would get inferred type `Foo { val x: 1 }`, so it could not
 be reassigned to a value of type `Foo { val x: 2 }` on the next line.
 
-Another approach might be to assume `tracked` for a `val` parameter `x`
-only if the class refers to a type member of `x`. But it turns out that this
-scheme is unimplementable since it would quickly lead to cyclic references
-when typechecking recursive class graphs. So an explicit `tracked` looks like the best available option.
+Another concern is that using tracked for all `val` parameters, including
+parameters of case classes could lead to large refinement types.
+
+Therefore, inferring tracked only for parameters with types that define abstract members is a usable compromise. After all, if we did not infer `tracked` for these types, any references to the abstract type via a path would likely produce compilation errors.
 
 ## Tracked members