feat(audio): log AudioService.asyncError instead of swallowing it

`AudioService.asyncError` had ZERO subscribers app-wide. The plugin funnels
every asynchronous failure of its own observers into that stream and nowhere
else — `_observePlaybackState`, `_observeMediaItem` and `_observeQueue` each
wrap their whole body in `catch (e) { _asyncError.add(e); }`, and the artwork
path uses `.catchError(_asyncError.add)` — and a `PublishSubject` with no
listeners simply drops what it is given. The platform-side exception behind
"the media playback notification disappeared" was therefore being discarded
without a single log line, which is why that report arrives with no evidence
attached.

`observarErroresAudio` is a pure, injectable seam in `arranque_audio.dart`
(stream in, logger callback out), matching the seam convention this codebase
already uses for `esperarArranqueAudio`, `decidirAvanceCola` and
`debeReaplicarEcualizador`: the unit tests exercise the wiring with a plain
`StreamController`, never the real plugin. The default logger emits one
`[PluriWave]`-prefixed `developer.log` line at `level: 900`, the same level
and prefix `servicio_audio.dart` already uses, so one logcat filter catches
both.

Wired from `lib/main.dart`, not from `arranque_audio.dart`: main.dart is the
module that genuinely owns handler lifecycle — it is the only caller of
`AudioService.init`, `registrarHandler` and `ServicioAudioSession`, and both
the on-time and the degraded/timeout startup branches converge on its
`conectarHandler` closure. `arranque_audio.dart` owns only the timeout race
and the degraded loading shell; it never creates or registers a handler
(`alListo` is injected into it from main.dart), so it has no lifecycle to
hang a subscription on. Subscribing happens before `AudioService.init` — the
getter only touches a static subject — so nothing reported during the
MediaBrowser handshake is missed, and one subscription covers both paths.

The subscription is cancellable and its `cancel` is registered into the
handler via `registrarLimpiezaArranque`, mirroring the existing
`registrarHandler` / `registrarFuenteNavegacion` / `registrarFuenteMusicaLocal`
registration convention. `onTaskRemoved` — the only handler teardown in this
app — runs it, so the subscription cannot outlive what it instruments. The
dependency points bootstrap -> service, so `servicio_audio.dart` never has to
import the bootstrap module or the plugin's static stream.

Zero behaviour change: nothing but log output is added.

lib/servicios/servicio_audio.dart

@@ -60,6 +60,23 @@ void registrarFuenteMusicaLocal(FuenteMusicaLocalAuto fuente) {
   _fuenteMusicaLocalGlobal = fuente;
 }
 
+/// Teardown hook for whatever `main.dart` wired around the handler and must
+/// be undone when the handler itself dies — today only the
+/// `AudioService.asyncError` subscription (`observarErroresAudio`). Registered
+/// from `main.dart`, mirroring [registrarHandler] and the two browse-source
+/// registrations above; run exactly once from
+/// [PluriWaveAudioHandler.onTaskRemoved].
+///
+/// The direction of the dependency matters: the bootstrap layer injects its
+/// cleanup INTO the service layer, so `servicio_audio.dart` never has to
+/// import `arranque_audio.dart` (nor the plugin's static error stream) just to
+/// be able to close it.
+Future<void> Function()? _limpiezaArranqueGlobal;
+
+void registrarLimpiezaArranque(Future<void> Function() limpieza) {
+  _limpiezaArranqueGlobal = limpieza;
+}
+
 /// Builds the phone-initiated "play a station" `MediaItem` (item 3, Android
 /// Auto fallback artwork): reuses [artUriPara] (`navegacion_auto.dart`) so a
 /// station with no usable favicon gets the SAME on-brand rotating fallback
@@ -1201,6 +1218,13 @@ class PluriWaveAudioHandler extends BaseAudioHandler
     await _androidAudioSessionIdSub?.cancel();
     await _player.dispose();
     await _androidAudioSessionIdController.close();
+    // Handler teardown: release the bootstrap-owned `AudioService.asyncError`
+    // subscription too, so it cannot outlive the handler it was instrumenting.
+    // Never throws out of teardown — a failing cleanup hook must not prevent
+    // the rest of `onTaskRemoved` from having completed above.
+    try {
+      await _limpiezaArranqueGlobal?.call();
+    } catch (_) {}
   }
 
   Emisora _emisoraDesdeMediaItem(MediaItem mediaItem) {