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/widgets/hoja_premium_test.dart

@@ -2,6 +2,7 @@ import 'dart:async';
 
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:in_app_purchase/in_app_purchase.dart';
 import 'package:pluriwave/estado/estado_entitlement.dart';
 import 'package:pluriwave/l10n/gen/app_localizations.dart';
 import 'package:pluriwave/servicios/servicio_compras.dart';
@@ -35,6 +36,28 @@ class _PuertoComprasFalso implements PuertoCompras {
   Future<void> dispose() => _eventos.close();
 }
 
+/// Fake [InAppPurchase]: permite montar el paywall sobre el
+/// `ServicioComprasPlayBilling` REAL (no un `PuertoCompras` falso) para cubrir
+/// el bloqueo del paywall de extremo a extremo. `noSuchMethod` cubre el resto
+/// de la API del plugin, que este test no ejercita.
+class _InAppPurchaseFalso implements InAppPurchase {
+  final _compras = StreamController<List<PurchaseDetails>>.broadcast();
+
+  @override
+  Stream<List<PurchaseDetails>> get purchaseStream => _compras.stream;
+
+  @override
+  Future<void> restorePurchases({String? applicationUserName}) async {
+    // Play Billing publica un lote VACÍO cuando no hay nada que restaurar.
+    _compras.add(const <PurchaseDetails>[]);
+  }
+
+  Future<void> dispose() => _compras.close();
+
+  @override
+  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
 /// FIX 3 / FIX 9 (code review): the paywall must show localized feedback for
 /// a failed purchase/restore, a distinct non-error confirmation when a
 /// restore finds nothing, and its own dedicated "premium active" string
@@ -298,4 +321,54 @@ void main() {
       },
     );
   });
+
+  group('bloqueo del paywall — "Restaurar compras" sin compras previas', () {
+    testWidgets('extremo a extremo (ServicioComprasPlayBilling real): un lote '
+        'vacío reactiva AMBOS botones, comprar y restaurar', (tester) async {
+      final iap = _InAppPurchaseFalso();
+      addTearDown(iap.dispose);
+      final servicio = ServicioComprasPlayBilling(inAppPurchase: iap);
+      addTearDown(servicio.dispose);
+
+      await tester.pumpWidget(
+        MultiProvider(
+          providers: [
+            ChangeNotifierProvider<EstadoEntitlement>(
+              create:
+                  (_) => EstadoEntitlement(prefs: null, compras: servicio),
+            ),
+          ],
+          child: MaterialApp(
+            locale: const Locale('es'),
+            localizationsDelegates: AppLocalizations.localizationsDelegates,
+            supportedLocales: AppLocalizations.supportedLocales,
+            home: const Scaffold(body: HojaPremium()),
+          ),
+        ),
+      );
+      await tester.pump();
+      l10n = AppLocalizations.of(tester.element(find.byType(HojaPremium)));
+
+      final restaurar = find.byKey(const ValueKey('hoja-premium-restaurar'));
+      final comprar = find.byKey(const ValueKey('hoja-premium-comprar'));
+
+      await tester.tap(restaurar);
+      await tester.pump();
+      await tester.pump();
+
+      // El botón sigue vivo: si `noEncontrada` nunca llega, `compraEnCurso`
+      // se queda en `true` y el usuario no puede pagar nunca más.
+      expect(
+        tester.widget<OutlinedButton>(restaurar).onPressed,
+        isNotNull,
+        reason: 'restaurar debe volver a estar habilitado',
+      );
+      expect(
+        tester.widget<FilledButton>(comprar).onPressed,
+        isNotNull,
+        reason: 'comprar debe volver a estar habilitado',
+      );
+      expect(find.text(l10n.restauracionSinCompras), findsOneWidget);
+    });
+  });
 }