chore: rename withDeadline to deadline

Author: ph1ps

Package.resolved

@@ -23,6 +23,6 @@ let package = Package(
         .product(name: "Clocks", package: "swift-clocks")
       ],
       swiftSettings: [.enableExperimentalFeature("StrictConcurrency")]
-    ),
+    )
   ]
 )

Package.swift

@@ -21,6 +21,6 @@ let package = Package(
         "Deadline",
         .product(name: "Clocks", package: "swift-clocks")
       ]
-    ),
+    )
   ]
 )

Package@swift-5.8.swift

@@ -13,26 +13,29 @@ Since this algorithm is not easy to get right and the implementation in [swift-a
 
 The library comes with two free functions, one with a generic clock. And another one which uses the `ContinuousClock` as default.
 ```swift
-public func withDeadline<C, R>(
+public func deadline<C, R>(
   until instant: C.Instant,
   tolerance: C.Instant.Duration? = nil,
   clock: C,
+  isolation: isolated (any Actor)? = #isolation,
   operation: @Sendable () async throws -> R
 ) async throws -> R where C: Clock, R: Sendable { ... }
 
-public func withDeadline<R>(
+public func deadline<R>(
   until instant: ContinuousClock.Instant,
   tolerance: ContinuousClock.Instant.Duration? = nil,
+  isolation: isolated (any Actor)? = #isolation,
   operation: @Sendable () async throws -> R
 ) async throws -> R where R: Sendable { ... }
 ```
 
 This function provides a mechanism for enforcing timeouts on asynchronous operations that lack native deadline support. It creates a `TaskGroup` with two concurrent tasks: the provided operation and a sleep task.
 
 - Parameters:
-  - `until`: The absolute deadline for the operation to complete.
+  - `instant`: The absolute deadline for the operation to complete.
   - `tolerance`: The allowed tolerance for the deadline.
   - `clock`: The clock used for timing the operation.
+  - `isolation`: The isolation passed on to the task group.
   - `operation`: The asynchronous operation to be executed.
 
 - Returns: The result of the operation if it completes before the deadline.
@@ -47,15 +50,15 @@ To fully understand this, let's illustrate the 3 outcomes of this function:
 #### Outcome 1
 The operation finishes in time:
 ```swift
-let result = try await withDeadline(until: .now + .seconds(5)) {
+let result = try await deadline(until: .now + .seconds(5)) {
   // Simulate long running task
   try await Task.sleep(for: .seconds(1))
   return "success"
 }
 ```
 As you'd expect, result will be "success". The same applies when your operation fails in time:
 ```swift
-let result = try await withDeadline(until: .now + .seconds(5)) {
+let result = try await deadline(until: .now + .seconds(5)) {
   // Simulate long running task
   try await Task.sleep(for: .seconds(1))
   throw CustomError()
@@ -66,7 +69,7 @@ This will throw `CustomError`.
 #### Outcome 2
 The operation does not finish in time:
 ```swift
-let result = try await withDeadline(until: .now + .seconds(1)) {
+let result = try await deadline(until: .now + .seconds(1)) {
   // Simulate even longer running task
   try await Task.sleep(for: .seconds(5))
   return "success"
@@ -79,7 +82,7 @@ The parent task was cancelled:
 ```swift
 let task = Task {
   do {
-    try await withDeadline(until: .now + .seconds(5)) {
+    try await deadline(until: .now + .seconds(5)) {
       try await URLSession.shared.data(from: url)
     }
   } catch {