fix: corregir ecualizador desincronizado, musica local en Android Auto y bloqueo del paywall

Tres fallos reportados en uso real, con sus causas raiz verificadas en codigo.

1. Ecualizador: el estado no tenia dueño unico

El handler arrancaba con `_ecualizadorActivo = true` a fuego. El valor
persistido solo llegaba por EstadoEcualizador.cargarPersistido(), alcanzable
unicamente desde el arbol de widgets, que un arranque headless de Android Auto
nunca construye. Resultado: el coche reproducia con el EQ forzado a ON mientras
disco e interfaz decian OFF.

Ahora registrarHandler siembra el flag desde disco en todos los motores y
setEcualizadorActivo persiste por su cuenta, asi que un toggle desde el coche o
la notificacion sobrevive sin EstadoEcualizador. _resincronizarConHandler pasa
a ser adopcion pura de interfaz.

Ademas mapearGananciaNativa enviaba 0 dB al punto MEDIO del rango nativo. Con
un getBandLevelRange() asimetrico, un preset plano metia varios dB de boost
real: la causa del "suena muy alto con el boton apagado". Reescrito para
escalar cada lado contra su propio extremo, de modo que 0 dB es siempre 0.

El dispatch de customAction no tenia ningun test. Se extrae decidirToggleEq y
se cubre contra el handler real. El efecto nativo se re-asierta al reactivarse
el reproductor, porque AudioEffect.setEnabled de just_audio es un no-op
mientras la plataforma esta desacoplada.

2. Musica Local no aparecia en el arbol de Android Auto

hayCarpetaConfigurada() consultaba MethodChannel('pluriwave/file_actions'),
registrado solo en MainActivity.configureFlutterEngine. Sin Activity no hay
handler, invokeMethod lanza MissingPluginException y el catch la confundia con
"permiso revocado", omitiendo el nodo. No dependia del entitlement.

La logica SAF sale a packages/pluriwave_file_actions, un paquete plugin local.
El motor headless que crea audio_service ejecuta GeneratedPluginRegistrant en
su constructor, asi que el canal queda registrado en ambos motores. Repuntar el
manifest a una subclase de AudioService no era viable: AudioServicePlugin
enlaza por ComponentName explicito y la app perderia el audio.

EstadoCarpetaLocal de tres valores separa "sin carpeta" de "canal no
disponible"; la raiz decide por la URI persistida y el subarbol muestra un item
explicativo en vez de una carpeta vacia. La invalidacion del arbol cacheado se
dispara al reanudar con el coche ya suscrito; el guardia anterior miraba
View.maybeOf, que bajo runApp siempre existe, por lo que se gastaba en el
arranque headless y no volvia a dispararse.

3. El paywall bloqueaba las compras

restorePurchases() de in_app_purchase_android emite siempre, y con lista vacia
si no hay nada que restaurar. El `if (compras.isEmpty) return;` se la tragaba,
noEncontrada nunca se emitia y la rama que limpia _compraEnCurso estaba muerta
en produccion. Como comprar y restaurar comparten ese flag, un usuario sin
compras que pulsaba restaurar se quedaba sin poder comprar.

Suite completa: 1366 pasan, 2 omitidos. 17 tests nuevos, todos nacidos rojos y
verificados por mutacion. flutter analyze mantiene los 5 avisos preexistentes.

test/servicios/musica_local_auto_test.dart

@@ -163,6 +163,132 @@ void main() {
       },
     );
   });
+  /// fix/android-auto-musica-local — «Muchísimas veces (la mayoría) no
+  /// aparece la opción de reproducir música local, no aparece ni el menú».
+  ///
+  /// El usuario TIENE la compra PRO, así que no es un problema de
+  /// entitlement. La causa real: `hasPersistedPermission` viaja por
+  /// `MethodChannel('pluriwave/file_actions')`, cuyo ÚNICO registro de
+  /// handler vive en `MainActivity.configureFlutterEngine`. Cuando Android
+  /// Auto levanta el MediaBrowserService sin que la app se haya abierto,
+  /// `audio_service` construye un FlutterEngine SIN Activity, ese método
+  /// nunca corre, el canal se queda sin handler y `invokeMethod` lanza
+  /// `MissingPluginException` — indistinguible hasta ahora de «permiso
+  /// revocado».
+  ///
+  /// Estos tests fijan la distinción: «el canal no está disponible» NO es
+  /// «no hay carpeta».
+  group('FuenteMusicaLocalAutoImpl.estadoCarpeta', () {
+    const canal = MethodChannel('pluriwave/file_actions');
+
+    tearDown(() {
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(canal, null);
+    });
+
+    test(
+      'con URI persistida y SIN handler nativo (motor headless de Android '
+      'Auto) reporta canalNoDisponible, no noConfigurada',
+      () async {
+        SharedPreferences.setMockInitialValues({
+          'musica_local_uri': 'content://tree/x',
+        });
+        // Sin handler: `invokeMethod` lanza MissingPluginException, que es
+        // exactamente lo que pasa en el motor sin Activity.
+        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+            .setMockMethodCallHandler(canal, null);
+
+        final fuente = FuenteMusicaLocalAutoImpl(
+          prefs: await SharedPreferences.getInstance(),
+        );
+
+        expect(
+          await fuente.estadoCarpeta(),
+          EstadoCarpetaLocal.canalNoDisponible,
+        );
+      },
+    );
+
+    test(
+      'con URI persistida y handler nativo que responde false (permiso '
+      'revocado de verdad) reporta noConfigurada',
+      () async {
+        SharedPreferences.setMockInitialValues({
+          'musica_local_uri': 'content://tree/x',
+        });
+        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+            .setMockMethodCallHandler(canal, (call) async {
+          expect(call.method, 'hasPersistedPermission');
+          return false;
+        });
+
+        final fuente = FuenteMusicaLocalAutoImpl(
+          prefs: await SharedPreferences.getInstance(),
+        );
+
+        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.noConfigurada);
+      },
+    );
+
+    test(
+      'con URI persistida y handler nativo que responde true reporta '
+      'configurada',
+      () async {
+        SharedPreferences.setMockInitialValues({
+          'musica_local_uri': 'content://tree/x',
+        });
+        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+            .setMockMethodCallHandler(canal, (call) async => true);
+
+        final fuente = FuenteMusicaLocalAutoImpl(
+          prefs: await SharedPreferences.getInstance(),
+        );
+
+        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.configurada);
+      },
+    );
+
+    test(
+      'sin URI persistida reporta noConfigurada sin invocar el canal',
+      () async {
+        SharedPreferences.setMockInitialValues({});
+        var llamadas = 0;
+        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+            .setMockMethodCallHandler(canal, (call) async {
+          llamadas++;
+          return true;
+        });
+
+        final fuente = FuenteMusicaLocalAutoImpl(
+          prefs: await SharedPreferences.getInstance(),
+        );
+
+        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.noConfigurada);
+        expect(llamadas, 0);
+      },
+    );
+
+    test(
+      'un PlatformException del canal (el handler SÍ existe, la llamada '
+      'falla) reporta noConfigurada, no canalNoDisponible',
+      () async {
+        SharedPreferences.setMockInitialValues({
+          'musica_local_uri': 'content://tree/x',
+        });
+        TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+            .setMockMethodCallHandler(canal, (call) async {
+          throw PlatformException(code: 'ERROR');
+        });
+
+        final fuente = FuenteMusicaLocalAutoImpl(
+          prefs: await SharedPreferences.getInstance(),
+        );
+
+        expect(await fuente.estadoCarpeta(), EstadoCarpetaLocal.noConfigurada);
+      },
+    );
+  });
+
   group('esArchivoAudio', () {
     test('acepta cualquier MIME audio/*, en cualquier capitalización', () {
       expect(esArchivoAudio('audio/mpeg', 'cancion.mp3'), isTrue);