[stdlib] Switch to a stable sort algorithm (swiftlang#19717)

This switches the standard library's sort algorithm from an in-place
introsort to use a modified timsort, a stable, adaptive sort that
merges runs using a temporary buffer. This implementation performs
straight merges instead of adopting timsort's galloping strategy.

In addition to maintaining the relative order of equal/non-comparable
elements, this algorithm outperforms the introsort on data with any
intrinsic structure, such as runs of ascending or descending elements
or a significant number of equality collisions.

Author: natecook1000

stdlib/public/core/CollectionAlgorithms.swift

@@ -320,14 +320,21 @@ extension MutableCollection where Self : BidirectionalCollection {
   ) rethrows -> Index {
     let maybeOffset = try _withUnsafeMutableBufferPointerIfSupported {
       (bufferPointer) -> Int in
-      let unsafeBufferPivot = try bufferPointer.partition(
+      let unsafeBufferPivot = try bufferPointer._partitionImpl(
         by: belongsInSecondPartition)
       return unsafeBufferPivot - bufferPointer.startIndex
     }
     if let offset = maybeOffset {
-      return index(startIndex, offsetBy: numericCast(offset))
+      return index(startIndex, offsetBy: offset)
+    } else {
+      return try _partitionImpl(by: belongsInSecondPartition)
     }
-
+  }
+  
+  @usableFromInline
+  internal mutating func _partitionImpl(
+    by belongsInSecondPartition: (Element) throws -> Bool
+  ) rethrows -> Index {
     var lo = startIndex
     var hi = endIndex
 

stdlib/public/core/Sort.swift

@@ -408,6 +408,13 @@ extension Unsafe${Mutable}BufferPointer {
     count = other.count
   }
 
+  @inlinable
+  public mutating func _withUnsafeMutableBufferPointerIfSupported<R>(
+    _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R
+  ) rethrows -> R? {
+    return try body(&self)
+  }
+
 %  else:
 
   /// Creates an immutable typed buffer pointer referencing the same memory as the