Use one allocation for the bespoke Mutex's storage. (#1584)

We currently use two allocations to store the contents of our bespoke
Apple-only `Mutex` reimplementation: one for the `os_unfair_lock` and
the other for the stored value. We can instead use a single allocation
with a bit of careful pointer arithmetic to ensure there's enough
storage for both and that it's well-aligned.

This change has the effect of reducing the size of `Mutex` by a word. It
also reduces the amount of memory allocated by some vague amount because
on Darwin, the minimum allocation size is 16 but the size of
`os_unfair_lock` is 4. I place the lock _after_ the value because its
alignment will often be smaller, so fewer padding bytes will be needed
between the value and the lock than between the lock and the value.

At compile time in release mode, all specializations are known and the
extra math is optimized away.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: grynspan

Sources/Testing/Support/Additions/MutexAdditions.swift

@@ -40,32 +40,48 @@ struct Mutex<Value>: Sendable, ~Copyable where Value: ~Copyable {
   private typealias _Lock = pthread_mutex_t
 #endif
 
+  /// Storage for both the lock and value.
+  private nonisolated(unsafe) let _baseAddress: UnsafeMutableRawPointer
+
+  /// The offset of `_lockAddress` from `_baseAddress`.
+  private static var _lockOffset: Int {
+    let p = UnsafeRawPointer(bitPattern: MemoryLayout<Value>.stride)!
+    return Int(bitPattern: p.alignedUp(for: _Lock.self))
+  }
+
   /// Storage for the underlying lock.
-  private nonisolated(unsafe) let _lockAddress: UnsafeMutablePointer<_Lock>
+  private var _lockAddress: UnsafeMutablePointer<_Lock> {
+    (_baseAddress + Self._lockOffset).assumingMemoryBound(to: _Lock.self)
+  }
 
   /// Storage for the value this instance guards.
-  private nonisolated(unsafe) let _valueAddress: UnsafeMutablePointer<Value>
+  private var _valueAddress: UnsafeMutablePointer<Value> {
+    _baseAddress.assumingMemoryBound(to: Value.self)
+  }
+
+
+  init(_ initialValue: consuming sending Value) {
+    _baseAddress = .allocate(
+      byteCount: Self._lockOffset + MemoryLayout<_Lock>.stride,
+      alignment: max(MemoryLayout<Value>.alignment, MemoryLayout<_Lock>.alignment)
+    )
 
-  public init(_ initialValue: consuming sending Value) {
-    _lockAddress = .allocate(capacity: 1)
 #if !SWT_NO_OS_UNFAIR_LOCK
     _lockAddress.initialize(to: .init())
 #else
     _ = pthread_mutex_init(_lockAddress, nil)
 #endif
-    _valueAddress = .allocate(capacity: 1)
     _valueAddress.initialize(to: initialValue)
   }
 
   deinit {
     _valueAddress.deinitialize(count: 1)
-    _valueAddress.deallocate()
 #if !SWT_NO_OS_UNFAIR_LOCK
     _lockAddress.deinitialize(count: 1)
 #else
     _ = pthread_mutex_destroy(_lockAddress)
 #endif
-    _lockAddress.deallocate()
+    _baseAddress.deallocate()
   }
 
   /// Acquire the lock.