Change handling of curried function types in capture checking

[odersky]

Implements the proposed treatment in cc-paths.

• Capture sets of curried functions don't automatically propagate to the left
• When computing the capture set of a reference, pick up capture sets along the span of curried functions
• Drop the previous syntactic sugar for propagating captures left to right in curried function types.

[odersky]

This is best reviewed commit by commit

[Linyxus]

Otherwise LGTM!

[Linyxus]

Suggested change

println(i"shot $actual $expected")

[odersky]

It's deleted in follow-up commit in the other PR.

[Linyxus]

Suggested change

	/** - Reset `private` flags of parameter accessors so that we can refine them
	/** - Reset `private` flags of parameter accessors so that we can refine them

[Linyxus]

Some meta-comments: currently only curried function closure stops capture propagation, but theoretically all function definitions could stop the propagation. For example:

val test1: Int ->{} Int ->{io} Int =
  x => y => {
    io.use()
    x + y
  }

val test2: Int ->{} Int ->{io} Int =
  x => {
    def f(y: Int): Int =
      io.use()
      x + y
    f
  }

By principle both cases should work but currently only the first one does. Could we make all function definitions stop the propagation of captures to allow cases like test2 as well?

[Linyxus]

After playing with more examples I discovered a soundness issue introduced by this PR:

trait Cap:
  def use(): Unit

def withCap[sealed T](op: (x: Cap^) => T): T = ???

trait Box:
  val get: () ->{} () ->{cap} Cap^

def main(): Unit =
  val leaked = withCap: (io: Cap^) =>
    class Foo extends Box, Pure:
      val get: () ->{} () ->{io} Cap^ = () => () => io
    new Foo
  val bad = leaked.get()().use()  // using a leaked capability

This is because curried function stops the captures from being propagated to the class's Env, so checking Foo against the Pure base passes (but it shouldn't). We probably need some special handling here: either tempering the capture propagation logic, or calculating the captured vars of a class "deeply" from its method types.