Ignoring all the details about synchronization and run loops and just trying to deal with this as it is, I believe we could reasonably make Swift allow this pattern. The problem is simply that Swift is treating a capture in a closure with different isolation as a send, when really we ought to be reasoning about the isolation of the functions the captured variable is used. This is a distinction that only matters with indirect captures, which is to say, when a variable is captured in a closure only because it is used in a further-nested closure. Because all of the contexts that actually access the captured variable share the same static isolation, it is straightforwardly true (in a way that Swift ought to be able to reliably prove) that none of those accesses can race even though the variable is also captured (but not accessed) by functions with a different static isolation.
Note that this would be more problematic if the captured variable had a non-Sendable type because of the deinit problem, although in this case Swift could simply force the capture to be destroyed on the right isolation.