[sending] Just like @sendable, sending stops isolation inference along DeclContexts.

Without this, we were hitting weird behaviors in flow_isolation.swift only when
compiling in Swift 5 mode.

Consider the following example:

```
func fakeTask(@_inheritActorContext _ x: sending @escaping () async -> ()) {}

actor MyActor {
    var x: Int = 5
    var y: Int = 6
    var hax: MyActor? = nil

    init() {
        fakeTask {
            // Warning! You can remove await
            // Error! Cannot access actor state in nonisolated closure.
            _ = await self.hax
        }
    }
}
```

The reason why this was happening is that we were not understanding that the
closure passed to fakeTask is not part of the init and has different isolation
from the init (it is nonisolated but does not have access to the init's state).
This then caused us to exit early and not properly process the isolation
crossing point there.

Now, we properly understand that a sending inheritActorContext closure (just
like an @sendable closure) has this property in actor initializers.

Author: gottesmm

lib/Sema/TypeCheckConcurrency.cpp

@@ -702,6 +702,49 @@ static bool isSendableClosure(
   return false;
 }
 
+/// Returns true if this closure acts as an inference boundary in the AST. An
+/// inference boundary is an expression in the AST where we newly infer
+/// isolation different from our parent decl context.
+///
+/// Examples:
+///
+///   1. a @Sendable closure.
+///   2. a closure literal passed to a sending parameter.
+///
+/// NOTE: This does not mean that it has nonisolated isolation since for
+/// instance one could define an @MainActor closure in a nonisolated
+/// function. That @MainActor closure would act as an Isolation Inference
+/// Boundary.
+///
+/// \arg forActorIsolation we currently have two slightly varying semantics
+/// here. If this is set, then we assuming that we are being called recursively
+/// while walking up a decl context path to determine the actor isolation of a
+/// closure. In such a case, we do not want to be a boundary if we should
+/// inheritActorContext. In other contexts though, we want to determine if the
+/// closure is part of an init or deinit. In such a case, we are walking up the
+/// decl context chain and we want to stop if we see a sending parameter since
+/// in such a case, the sending closure parameter is known to not be part of the
+/// init or deinit.
+static bool
+isIsolationInferenceBoundaryClosure(const AbstractClosureExpr *closure,
+                                    bool forActorIsolation) {
+  if (auto *ce = dyn_cast<ClosureExpr>(closure)) {
+    if (!forActorIsolation) {
+      // For example, one would along this path see if for flow sensitive
+      // isolation the closure is part of an init or deinit.
+      if (ce->isPassedToSendingParameter())
+        return true;
+    } else {
+      // This is for actor isolation. If we have inheritActorContext though, we
+      // do not want to do anything since we are part of our parent's isolation.
+      if (!ce->inheritsActorContext() && ce->isPassedToSendingParameter())
+        return true;
+    }
+  }
+
+  return isSendableClosure(closure, forActorIsolation);
+}
+
 /// Add Fix-It text for the given nominal type to adopt Sendable.
 static void addSendableFixIt(
     const NominalTypeDecl *nominal, InFlightDiagnostic &diag, bool unchecked) {
@@ -1628,11 +1671,14 @@ bool ReferencedActor::isKnownToBeLocal() const {
 const AbstractFunctionDecl *
 swift::isActorInitOrDeInitContext(const DeclContext *dc) {
   while (true) {
-    // Non-Sendable closures are considered part of the enclosing context.
+    // Stop looking if we hit an isolation inference boundary.
     if (auto *closure = dyn_cast<AbstractClosureExpr>(dc)) {
-      if (isSendableClosure(closure, /*for actor isolation*/ false))
+      if (isIsolationInferenceBoundaryClosure(closure,
+                                              false /*is for actor isolation*/))
         return nullptr;
 
+      // Otherwise, look through our closure at the closure's parent decl
+      // context.
       dc = dc->getParent();
       continue;
     }
@@ -4202,22 +4248,17 @@ namespace {
               .withPreconcurrency(preconcurrency);
       }
 
-      // Sendable closures are nonisolated unless the closure has
-      // specifically opted into inheriting actor isolation.
-      if (isSendableClosure(closure, /*forActorIsolation=*/true))
+      // If we have a closure that acts as an isolation inference boundary, then
+      // we return that it is non-isolated.
+      //
+      // NOTE: Since we already checked for global actor isolated things, we
+      // know that all Sendable closures must be nonisolated. That is why it is
+      // safe to rely on this path to handle Sendable closures.
+      if (isIsolationInferenceBoundaryClosure(
+              closure, true /*is for closure isolation*/))
         return ActorIsolation::forNonisolated(/*unsafe=*/false)
             .withPreconcurrency(preconcurrency);
 
-      // If the explicit closure is used as a non-Sendable sending parameter,
-      // make it nonisolated by default instead of inferring its isolation from
-      // the context.
-      if (auto *explicitClosure = dyn_cast<ClosureExpr>(closure)) {
-        if (!explicitClosure->inheritsActorContext() &&
-            explicitClosure->isPassedToSendingParameter())
-          return ActorIsolation::forNonisolated(/*unsafe=*/false)
-              .withPreconcurrency(preconcurrency);
-      }
-
       // A non-Sendable closure gets its isolation from its context.
       auto parentIsolation = getActorIsolationOfContext(
           closure->getParent(), getClosureActorIsolation);