fix: Hold the 2-way audio backchannel open for the shortest possible time (#2697)

The card claimed a camera's ONVIF audio backchannel in two places that
had
nothing to do with a call: the capability probe at camera init
(`&microphone`),
and a pre-armed `sendonly` audio transceiver on every live WebRTC offer.
Merely
looking at a dashboard occupied the camera's speaker line. Outbound
audio now
travels on its own audio-only WebRTC connection, opened when a call is
answered
and closed when it ends.

- The backchannel is claimed only for the duration of a call. Idle
viewing
  claims nothing.
- Two-way audio now works in `mse`, `mp4` and `mjpeg` modes (note: the
outbound
  audio still traverses WebRTC).
- No renegotiation and no video blink at call start or end.
- A call that cannot carry audio now reports it and ends, instead of
showing a
  live microphone that goes nowhere.
- `live.microphone.always_connected` is now purely about the browser
microphone
  permission prompt.
- Call setup measured at 66ms (LAN) and ~260ms (cellular) for ICE and
DTLS, plus
  ~300ms for `go2rtc` to open an RTSP backchannel.

Verified against a live Frigate + `go2rtc` instance, and by unit tests
at 100%
coverage.

 - Closes #2691
 - Closes #2039
 - Closes #2178

Ref #2299 -- the probe no longer opens a backchannel, but it still runs
per
camera on every load and reconnect, and still dials the camera on the
direct-`go2rtc` path. Caching remains to be done.

Ref AlexxIT/go2rtc#1860 -- once a call has opened a backchannel,
`go2rtc` keeps
that media set up on the camera's RTSP session for the life of the
producer.

Diagnoses #2678

tests/card-controller/microphone-manager.test.ts

@@ -518,10 +518,63 @@ describe('MicrophoneManager', () => {
     });
   });
 
+  describe('should handle the device disappearing', () => {
+    const endTrack = (stream: MediaStream): void => {
+      const track = getTrack(stream);
+      vi.mocked(track.addEventListener)
+        .mock.calls.filter(([type]) => type === 'ended')
+        .forEach(([, listener]) => (listener as EventListener)(new Event('ended')));
+    };
+
+    it('should release a stream whose track ends', async () => {
+      const stream = createMockStream();
+      vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(stream);
+
+      const api = createCardAPI();
+      const manager = new MicrophoneManager(api);
+      manager.setTransmissionActive(true);
+      await manager.connect();
+      expect(manager.isConnected()).toBeTruthy();
+
+      endTrack(stream);
+
+      expect(manager.isConnected()).toBeFalsy();
+      expect(manager.getStream()).toBeNull();
+    });
+
+    it('should stop listening to a stream that has been replaced', async () => {
+      const streamA = createMockStream();
+      vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(streamA);
+      const api = createCardAPI();
+      const manager = new MicrophoneManager(api);
+      manager.setTransmissionActive(true);
+      await manager.connect();
+
+      const streamB = createMockStream();
+      vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(streamB);
+      await manager.connect();
+
+      const track = getTrack(streamA);
+      const added = vi
+        .mocked(track.addEventListener)
+        .mock.calls.find(([type]) => type === 'ended');
+      const removed = vi
+        .mocked(track.removeEventListener)
+        .mock.calls.find(([type]) => type === 'ended');
+
+      expect(added).toBeDefined();
+      expect(removed?.[1]).toBe(added?.[1]);
+      expect(manager.getStream()).toBe(streamB);
+    });
+  });
+
   describe('should require initialization', async () => {
     it('should require when configured and supported', async () => {
       const api = createCardAPI();
       const manager = new MicrophoneManager(api);
+      vi.mocked(navigatorMock.mediaDevices.getUserMedia).mockResolvedValue(
+        createMockStream(),
+      );
       vi.mocked(api.getConfigManager().getConfig).mockReturnValue(
         createConfig({
           live: {