[5.5][concurrency] Implement support for Task local exclusivity access sets.

[gottesmm]

The implemented semantics are that:

1. Tasks have separate exclusivity access sets.
2. Any synchronous context that creates tasks will have its exclusive access set merged into the Tasks while the Task is running.

rdar://80492364

---

CCC

Explanation: Exclusivity and concurrency are incompatible due to exclusivity relying on thread local storage to store exclusive access sets. This results in different Tasks potentially having the same access set (breaking the program model where we have not defined any such relationship) and also the possibility of an access associated with a task beginning on one thread and then ending on a different thread if the task runs on a different thread (causing the exclusivity runtime to crash since it can't find the access).

In this change, I fix these issues by:

1. Reserving 2 pointers in each AsyncTask to store an access set.
2. When the task begins executing on a thread, we merge its current access set into the exclusivity thread local access set and when the task ends, we unmerge the Task's access set from the exclusivity access set and serialize the task access set into the task. This is safe since we are guaranteed by the model that all async Tasks will be started from a synchronous context (when we switch tasks, we always pop to a sync context and then push the new context).

Scope: Without this change, Tasks will (depending if they are on the same thread) hit exclusivity violations and the runtime may hit nullptrs at runtime if an access for a Task begins on one thread and is ended on a different Thread that the task runs upon.

SR Issue: rdar://80492364

Risk: Medium. Since this is a semantic change, I think it is a medium risk change. That being said, I think the exhaustive testing significantly reduces the risk.

Testing: I wrote exhaustive tests of all of the cases that the runtime can hit. I provided both runtime tests and specific logging based FileCheck tests.

Reviewer: @mikeash

Example:

// This example crashes without the change since our two Tasks do not have separate exclusivity access sets.
@MainActor func callee2 (_ x: inout Int) async -> Void { ... }

@MainActor
func callee1(_ x: inout Int) async -> () {
    let handle = Task { @MainActor in
        // ==><==. Crash!!! Simultaneous Access?!
        await callee2(&global1)
    }
    await handle.value
}

@MainActor func test() async {
    await callee1(&global1)
}

[gottesmm]

@swift-ci test

[swift-ci]

Build failed
Swift Test Linux Platform
Git Sha - 0d4bd2ff5e97a1330f8c049e9a67337818520515

[gottesmm]

@swift-ci test

[gottesmm]

@swift-ci test

[gottesmm]

@swift-ci nominate