test: feed frames continuously when publishing buffer tracks

`publishManyTracks` captured a single frame before each `publish(videoTrack:)`
and discarded `CVPixelBufferCreate`'s result, so a failed allocation captured
nothing at all. `BufferCapturer` documents both halves of what that breaks:
`capture(_:)` is meant to be called repeatedly, and dimensions must resolve
before publishing or the publish times out — they come only from a real frame,
not from `BufferCaptureOptions(dimensions:)`.

Server logs show the effect: five of six tracks published in 2-6ms each, then
video-2 sat for 10.6s and failed with `Timed out` without any `add_track`
reaching the SFU.

Keep frames flowing until publish returns, matching how
`PublishBufferCapturerTests` drives its buffer track. A fresh buffer per capture
keeps anything non-Sendable out of the feeding task, and `#require` replaces the
discarded allocation result.

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

Author: pblazej

Tests/LiveKitCoreTests/PeerConnectionSignalingTests.swift

@@ -348,13 +348,19 @@ struct PeerConnectionSignalingTests {
 
             for i in 0 ..< videoCount {
                 let track = LocalVideoTrack.createBufferTrack(name: "video-\(i)")
-                guard let capturer = track.capturer as? BufferCapturer else {
-                    Issue.record("Expected BufferCapturer")
-                    return
+                let capturer = try #require(track.capturer as? BufferCapturer)
+
+                // `BufferCapturer` resolves dimensions only from captured frames and
+                // is documented to be fed repeatedly, so keep frames flowing until
+                // publish returns rather than relying on a single one landing in time.
+                let frames = Task.detached {
+                    while !Task.isCancelled {
+                        if let buffer = Self.makeTestPixelBuffer() { capturer.capture(buffer) }
+                        try? await Task.sleep(nanoseconds: 50_000_000)
+                    }
                 }
-                var pixelBuffer: CVPixelBuffer?
-                CVPixelBufferCreate(kCFAllocatorDefault, 320, 240, kCVPixelFormatType_32BGRA, nil, &pixelBuffer)
-                if let pixelBuffer { capturer.capture(pixelBuffer) }
+                defer { frames.cancel() }
+
                 try await room1.localParticipant.publish(videoTrack: track)
                 try await Task.sleep(nanoseconds: 500_000_000)
             }
@@ -392,6 +398,16 @@ struct PeerConnectionSignalingTests {
         }
     }
 
+    /// A fresh blank frame. Created per capture so nothing non-Sendable crosses
+    /// into the feeding task.
+    private static func makeTestPixelBuffer() -> CVPixelBuffer? {
+        var pixelBuffer: CVPixelBuffer?
+        guard CVPixelBufferCreate(kCFAllocatorDefault, 320, 240, kCVPixelFormatType_32BGRA, nil, &pixelBuffer) == kCVReturnSuccess else {
+            return nil
+        }
+        return pixelBuffer
+    }
+
     private static var isLocalhost: Bool {
         let url = TestEnvironment.liveKitServerUrl()
         return url.contains("localhost") || url.contains("127.0.0.1")