Thanks to you and @nkbelov for the excellent, clear replies. I see the benefit of the primitive and the need for a handle/reference type.
Looking at legacy [ManagedAtomic], I liked the work put into inlining API into clients (at the cost of replicating all the available semantics) and the purpose-built Storage. But perhaps the hoops to get to the atomic access are likely not significant (performance-wise) relative to the complications over a final class with limited access.
But I don't want to give up yet, and this is where I strain at the abstractions a bit in my limited understanding. I assume the storage in memory is moveable (hence the effort to make AtomicRepresentable bit-copiable and the risk of managing pointer directly). ~Copyable for move-only types makes it easier for the compiler to track actual moves, and should make it possible e.g., to prove that all references are in the same stack (or even the same register?), and I was hoping that code from different tasks using an atomic value in the same isolation region wouldn't always have to go to main memory. If I always have to use a class reference, then that would seem to prevent the compiler from optimizing producer/consumer pairs in the same isolation domain when they share a lightweight thread. I had an admittedly vague understanding that the inlining and Storage of ManagedAtomic made that possible, but perhaps an ordinary class restricted to a domain is enough?
My naive impression of go channels is that they manage to put the producer/consumer pair on the same lightweight thread (or at least they share the same go stack?) to avoid main memory or a full context switch when the pair is alternating. Is that possible in Swift?
(This brings up other questions about the scope affected by the memory orderings, but that's a separate issue.)
(Again, apologies if the question is bad, since this is mostly above my pay grade)
Edit: as a reminder from last year's discussion
That was perhaps assuming an older implementation:
Perhaps the producer can use await to call consumers with a borrowing atomic parameter.
[ManagedAtomic] - https://github.com/apple/swift-atomics/blob/main/Sources/Atomics/Types/ManagedAtomic.swift