fix(eq): resync EstadoEcualizador with car/notification-initiated changes

A toggle from the Android Auto notification or a preset picked from the
car's EQ folder mutated PluriWaveAudioHandler state directly, leaving
EstadoEcualizador (and therefore the phone UI) unaware and never
persisting the change, so it was lost on the next app restart.

Forward the handler's ecualizadorActivo flag through ServicioAudio and,
mirroring EstadoRadio's existing playFromMediaId resync, diff it plus
presetActual against the cached values on every estadoStream tick,
adopting and persisting a divergence via ServicioEcualizador.

test/estado/estado_ecualizador_test.dart

@@ -1728,6 +1728,132 @@ void main() {
       eq.dispose();
     });
   });
+
+  // ---------------------------------------------------------------------------
+  // eq-sync-superficies: car/notification-initiated EQ changes must reach
+  // EstadoEcualizador (and persist through ServicioEcualizador), not just
+  // the audio handler.
+  // ---------------------------------------------------------------------------
+
+  group('EstadoEcualizador — resync with handler-initiated EQ changes '
+      '(eq-sync-superficies)', () {
+    test(
+      'a handler-initiated toggle (car/notification) syncs activo and '
+      'notifies listeners',
+      () async {
+        final fakeAudio = FakeServicioAudio();
+        final eq = EstadoEcualizador(
+          audio: fakeAudio,
+          servicio: FakeServicioEcualizador(activo: true),
+        );
+        await eq.cargarPersistido();
+        expect(eq.activo, isTrue);
+
+        var avisos = 0;
+        eq.addListener(() => avisos++);
+
+        // Simulates `accionEqToggle` calling
+        // `PluriWaveAudioHandler.setEcualizadorActivo` directly, bypassing
+        // `ServicioAudio`/`EstadoEcualizador` entirely.
+        fakeAudio.simularCambioEqDesdeHandler(activo: false);
+        await Future<void>.delayed(const Duration(milliseconds: 50));
+
+        expect(eq.activo, isFalse);
+        expect(avisos, greaterThanOrEqualTo(1));
+        eq.dispose();
+      },
+    );
+
+    test(
+      'a handler-initiated preset change (Android Auto) syncs presetActual '
+      'and notifies listeners',
+      () async {
+        final fakeAudio = FakeServicioAudio();
+        final eq = EstadoEcualizador(
+          audio: fakeAudio,
+          servicio: FakeServicioEcualizador(principal: PresetEcualizador.flat),
+        );
+        await eq.cargarPersistido();
+        expect(eq.presetActual, equals(PresetEcualizador.flat));
+
+        var avisos = 0;
+        eq.addListener(() => avisos++);
+
+        // Simulates `seleccionarPresetEqPorMediaId` calling
+        // `PluriWaveAudioHandler.aplicarPreset` directly.
+        fakeAudio.simularCambioEqDesdeHandler(preset: PresetEcualizador.jazz);
+        await Future<void>.delayed(const Duration(milliseconds: 50));
+
+        expect(eq.presetActual, equals(PresetEcualizador.jazz));
+        expect(avisos, greaterThanOrEqualTo(1));
+        eq.dispose();
+      },
+    );
+
+    test(
+      'a handler-initiated toggle is persisted through ServicioEcualizador '
+      '(survives a restart)',
+      () async {
+        final fakeAudio = FakeServicioAudio();
+        final fakeServicio = FakeServicioEcualizador(activo: true);
+        final eq = EstadoEcualizador(audio: fakeAudio, servicio: fakeServicio);
+        await eq.cargarPersistido();
+
+        fakeAudio.simularCambioEqDesdeHandler(activo: false);
+        await Future<void>.delayed(const Duration(milliseconds: 50));
+
+        expect(fakeServicio.config.activo, isFalse);
+        expect(fakeServicio.guardarActivoLlamadas, equals(1));
+        eq.dispose();
+      },
+    );
+
+    test(
+      'resync does not cause an extra handler write (no feedback loop)',
+      () async {
+        final fakeAudio = FakeServicioAudio();
+        final eq = EstadoEcualizador(
+          audio: fakeAudio,
+          servicio: FakeServicioEcualizador(activo: true),
+        );
+        await eq.cargarPersistido();
+        fakeAudio.cambiosEcualizadorActivo.clear();
+        fakeAudio.presetsAplicados.clear();
+
+        fakeAudio.simularCambioEqDesdeHandler(activo: false);
+        await Future<void>.delayed(const Duration(milliseconds: 50));
+
+        // The resync must only read from `audio` and write to `servicio` —
+        // never write BACK into `audio`, or a handler write would trigger
+        // another stream tick, which would resync again, forever.
+        expect(fakeAudio.cambiosEcualizadorActivo, isEmpty);
+        expect(fakeAudio.presetsAplicados, isEmpty);
+        eq.dispose();
+      },
+    );
+
+    test(
+      'a UI-initiated toggle still works exactly as before and persists '
+      'exactly once (regression)',
+      () async {
+        final fakeAudio = FakeServicioAudio();
+        final fakeServicio = FakeServicioEcualizador(activo: true);
+        final eq = EstadoEcualizador(audio: fakeAudio, servicio: fakeServicio);
+        await eq.cargarPersistido();
+        fakeAudio.cambiosEcualizadorActivo.clear();
+
+        await eq.cambiarActivo(false);
+        // Give any (harmless, no-op) resync tick a chance to run too.
+        await Future<void>.delayed(const Duration(milliseconds: 50));
+
+        expect(eq.activo, isFalse);
+        expect(fakeServicio.config.activo, isFalse);
+        expect(fakeServicio.guardarActivoLlamadas, equals(1));
+        expect(fakeAudio.cambiosEcualizadorActivo, equals([false]));
+        eq.dispose();
+      },
+    );
+  });
 }
 
 /// Fake whose [guardarActivo] stays pending until released, and releases the

test/estado/estado_radio_test.dart

@@ -77,7 +77,7 @@ void main() {
         final porEmisora = {'fav-1': PresetEcualizador.rock};
         final estado = EstadoRadio(
           esPremium: () => true,
-          audio: FakeServicioAudio(ecualizadorActivo: false),
+          audio: FakeServicioAudio(ecualizadorDisponible: false),
           favoritos: FakeServicioFavoritos(),
           radio: FakeServicioRadio(),
           servicioEcualizador: FakeServicioEcualizador(