Fix #IsolatedConformances warning in subscribeOnMainActor

Swift 6.2 emits `#IsolatedConformances` (SE-0470) when `for try await`
runs on `@MainActor`, since the iterator's `AsyncIteratorProtocol`
conformance may be MainActor-isolated. Run iteration on `@concurrent`
and hop to MainActor per element. Drop the unused stateful overload
and its `MainActorStateBox` helper — all call sites use the no-state
form. Pre-6.2 keeps the original `@MainActor` body via `#if compiler`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: pblazej

Sources/LiveKit/Support/Async/AsyncSequence+Subscribe.swift

@@ -86,60 +86,47 @@ extension AsyncSequence where Element: Sendable, Self: Sendable {
     /// - Parameters:
     ///   - observer: The observer object (captured weakly).
     ///   - priority: The priority of the task.
-    ///   - state: The initial mutable state.
     ///   - onElement: Called for each element on the MainActor.
-    ///   - onFailure: Called when the sequence terminates with an error on the MainActor. Skipped on cancellation.
+    ///   - onFailure: Called when the sequence terminates with an error on the MainActor. Cancellation errors are ignored.
     /// - Returns: The task cancellable.
     @MainActor
-    func subscribeOnMainActor<O: AnyObject & Sendable, State: Sendable>(
+    func subscribeOnMainActor<O: AnyObject & Sendable>(
         _ observer: O,
         priority: TaskPriority? = nil,
-        state: State,
-        onElement: @escaping @MainActor (O, Element, inout State) async -> Void,
-        onFailure: (@MainActor (O, Error, inout State) async -> Void)? = nil
+        onElement: @escaping @MainActor (O, Element) async -> Void,
+        onFailure: (@MainActor (O, Error) async -> Void)? = nil
     ) -> AnyTaskCancellable {
-        Task(priority: priority) { @MainActor [weak observer] in
-            var state = state
+        // Swift 6.2 emits `#IsolatedConformances` when `for try await` runs on `@MainActor` (SE-0470);
+        // iterate on `@concurrent` and hop per element. Older toolchains keep the `@MainActor` body.
+        #if compiler(>=6.2)
+        return Task(priority: priority) { @concurrent [weak observer] in
             do {
                 for try await element in self {
                     guard let observer else { break }
-                    await onElement(observer, element, &state)
+                    await onElement(observer, element)
                 }
             } catch {
                 if error is CancellationError || Task.isCancelled { return }
                 if let observer, let onFailure {
-                    await onFailure(observer, error, &state)
+                    await onFailure(observer, error)
                 }
             }
         }.cancellable()
-    }
-
-    /// Subscribe to an AsyncSequence with a lifecycle tied to an observer on the MainActor.
-    ///
-    /// The loop automatically terminates if the observer is deallocated.
-    ///
-    /// - Parameters:
-    ///   - observer: The observer object (captured weakly).
-    ///   - priority: The priority of the task.
-    ///   - onElement: Called for each element on the MainActor.
-    ///   - onFailure: Called when the sequence terminates with an error on the MainActor. Cancellation errors are ignored.
-    /// - Returns: The task cancellable.
-    @MainActor
-    func subscribeOnMainActor<O: AnyObject & Sendable>(
-        _ observer: O,
-        priority: TaskPriority? = nil,
-        onElement: @escaping @MainActor (O, Element) async -> Void,
-        onFailure: (@MainActor (O, Error) async -> Void)? = nil
-    ) -> AnyTaskCancellable {
-        subscribeOnMainActor(
-            observer,
-            priority: priority,
-            state: (),
-            onElement: { observer, element, _ in await onElement(observer, element) },
-            onFailure: { observer, error, _ in
-                if let onFailure { await onFailure(observer, error) }
+        #else
+        return Task(priority: priority) { @MainActor [weak observer] in
+            do {
+                for try await element in self {
+                    guard let observer else { break }
+                    await onElement(observer, element)
+                }
+            } catch {
+                if error is CancellationError || Task.isCancelled { return }
+                if let observer, let onFailure {
+                    await onFailure(observer, error)
+                }
             }
-        )
+        }.cancellable()
+        #endif
     }
 }