[6.2][sema] Work around a double curry thunk actor isolation inference bug that is a knock on effect of ced96aa5cd653f834d2a8293ead8cf46649202cb.

[gottesmm]

Explanation: There is currently a bug in TypeCheckConcurrency.cpp where we do not visit autoclosures. This causes us to never set the autoclosure's ActorIsolation field like all other closures. For a long time we were able to get away with this just by relying on the isolation of the decl context of the autoclosure... but with the introduction of nonisolated(nonsending), we found cases where the generated single curry autoclosure would necessarily be different than its decl context (e.x.: a synchronous outer curry thunk that is nonisolated that returns an inner curry thunk that is nonisolated(nonsending)). This problem caused us to hit asserts later in the compiler since the inner closure was actually nonisolated(nonsending), but we were thinking that it should have been concurrent.

To work around this problem, I changed the type checker in ced96aa to explicitly set the isolation of single curry thunk autoclosures when it generates them. The reason why we did this is that it made it so that we did not have to have a potential large source break in 6.2 by changing TypeCheckConcurrency.cpp to visit all autoclosures it has not been visiting.

This caused a follow on issue where since we were now inferring the inner autoclosure to have the correct isolation, in cases where we were creating a double curry thunk for an access to a global actor isolated field of a non-Sendable non-global actor isolated nominal type, we would have the outer curry thunk have unspecified isolation instead of main actor isolation. An example of this is the following:

class A {
  var block:  @MainActor () -> Void = {}
}

class B {
  let a = A()

  func d() {
    a.block = c // Error! Passing task isolated 'self' to @MainActor closure.
  }

  @MainActor
  func c() {}
}

This was unintentional. To work around this, this commit changes the type checker to explicitly set the double curry thunk isolation to the correct value when the type checker generates the double curry thunk in the same manner as it does for single curry thunks and validates that if we do set the value to something explicitly that it has the same value as the single curry thunk.

I also discovered in the process that I needed to add an ActorIsolationCrossing for these auto closures since as a result of not visiting them, we were not getting those set which caused us to no longer emit errors as we should in these cases. I did it /only/ for auto closures that have isolation set which can only be one of these double/single curry thunk auto closures since no other auto closures will have their isolation set.

Scope: Changes the actor isolation only of double curry thunks in the type checker and teaches the type checker how to detect if single or double curry thunks cause an actor isolation crossing to ensure we emit diagnostics.

Resolves: rdar://152522631

Main PR: #82375

Risk: Low. This only impacts code that uses double curry thunks and single curry thunks. Any other code that does not use curry thunks will not be impacted. So the impact is very localized on purpose.

Testing: Added compiler tests

Reviewer: @xedin

[gottesmm]

@swift-ci test