Some test cases that demonstrate that Scala's type system is currently not precise enough when it comes to
dependent classes.

For a tracked class parameter we add a refinement in the constructor type that
the class member is the same as the parameter. E.g.
```scala
class C { type T }
class D(tracked val x: C) { type T = x.T }
```
This will generate the constructor type:
```scala
(x1: C): D { val x: x1.type }
```
Without `tracked` the refinement would not be added. This can solve several problems with dependent class
types where previously we lost track of type dependencies.

…arameters

Needs an addition to Tasty format: TRACKED as a modifier.

This commit makes all explicitly declared vals tracked. It causes many test failures, which
makes it unlikely that we will be able to do this in the end. But it's an excellent basis
for stress testing the implementation of dependent classes.

The idea is to

 - look at the test failures in this test
 - convert failing tests into tests witih explicit tracked annotations
 - if the test still fails (it probably will), try to fix the root cause
   or determine that the pattern should not be supported.