Add a primitive storage for managing critical state and platform abstracted locking

[phausler]

This is a pre-requisite for managing state for backing storage that cannot be managed as an actor (due to cancellation). Locking is heavily inspired from the cross platform implementation in swift-corelibs-foundation (but skipping the try lock and the recursive variant).

ManagedCriticalState is an abstraction around that locking primitive in addition controlling mutations to a stored value. This allows for transactions from multiple queues/actors/threads to shared state without requiring the memory layout of the stored value to fit into an atomic intrinsic.

With the state of withTaskCancellationHandler this becomes distinctly important for the cancel closure since that is NOT asynchronous and therefore cannot be meaningfully used with an actor. There is additional utility that this type could provide to non async/await code and perhaps should be considered for refinement into the standard library. (we seem to need this pattern a lot...)

[jmschonfeld]

LGTM overall 👍🏻

[natecook1000]

Just out of curiosity, why do you prefer storing the primitive and calling these static versions, instead of just storing a Lock instance and calling $0.lock()?

[phausler]

the issue with storing a lock is that first off should be a move only type (and we don't have that yet). and second off we need to have some sort of de-initialization of it (triggered by the deallocation of the managed buffer)

Lock itself is useful when you do have it separated out rather than just in use for the managed critical state. so this way we funnel everything to the same source of truth.