fix: el coche recuerda la ultima emisora y deja de publicar una sesion fantasma

Tres defectos preexistentes alrededor de la reanudacion en Android Auto. Ninguno
es una regresion: el consumidor (la raiz `recent`) se añadio en septiembre y es
lo que dejo el hueco a la vista.

La ultima emisora solo la escribia el telefono

La clave `ultima_emisora_v1` tenia como unico escritor a
`EstadoRadio._persistirUltimaEmisora`, y `EstadoRadio` solo existe si hay arbol
de widgets. El motor que arranca Android Auto es headless de verdad, asi que una
sesion que ocurriera solo en el coche jamas actualizaba la clave y al reconectar
se ofrecia la emisora de la ultima vez que se uso el movil.

El handler recibe ahora sus puertos de lectura y escritura, con la misma forma
que los del ecualizador y el contexto de salto, y escribe desde `_cambiarFuente`:
el cuello de botella por el que pasan todas las rutas -- telefono, toque en el
coche, voz, saltos, avance de cola y la propia reanudacion.

Se ELIMINA el escritor del telefono en vez de sumar un segundo. Dos escritores
independientes de la misma clave acaban divergiendo siempre; es exactamente lo
que ya costo varias rondas con el flag del ecualizador.

Las pistas locales quedan excluidas: un `content://` guardado como ultima
emisora seria una fila de reanudacion que no resuelve a nada.

play() sin fuente levantaba un servicio en primer plano vacio

just_audio publica `playing:true` antes de comprobar si hay fuente, asi que un
`play()` en frio no tocaba la plataforma pero si emitia ese estado sobre
`processingState: idle`. audio_service entraba en estado de reproduccion
mientras el estado nativo seguia en NONE: notificacion con boton de pausa, cero
audio, sin titulo ni caratula, y un Future que no se completaba nunca. El coche
enruta su tecla de play directamente ahi.

Ahora `play()` sin fuente abierta restaura la ultima emisora por la ruta normal,
y si no hay nada que restaurar no toca el reproductor ni publica nada.

En frio no habia metadatos que enseñar

El unico `mediaItem.add` util vivia dentro de `_cambiarFuente`, asi que en un
motor recien arrancado el lado nativo nunca recibia metadatos. Se siembra el
`mediaItem` de la emisora persistida sin cargar ni reproducir nada, con guarda
antes y despues de la lectura de disco para no pisar una emisora ya sonando.

`getMediaItem` resolvia solo contra el universo completo -- vacio en el motor del
coche -- mientras `porUuid` si caia en las destacadas. El coche podia navegar una
emisora destacada y luego no resolver su ficha. Ambos usan ahora la misma ruta.

Suite completa: 1529 pasan, 2 omitidos. flutter analyze mantiene los 5 avisos
preexistentes.

lib/servicios/emisoras_destacadas.dart

@@ -155,6 +155,28 @@ Future<bool> esEmisoraGratuitaPorUuid(
 Future<Emisora?> ultimaEmisoraPersistida({SharedPreferences? prefs}) =>
     _ultimaEmisora(prefs: prefs);
 
+/// Writes [emisora] as the last-played station — the SINGLE writer of
+/// [claveUltimaEmisora].
+///
+/// It lives beside [ultimaEmisoraPersistida] rather than in `EstadoRadio`
+/// because the key has to be written from the engine Android Auto starts,
+/// which builds no widget tree and therefore never constructs `EstadoRadio`
+/// at all: a session that happened only in the car used to leave the key
+/// holding whatever the PHONE last played, so the head unit's resume row and
+/// the free tier's featured folder were both stale on the next connect.
+///
+/// Deliberately NOT swallowing failures here: the handler port that calls it
+/// traces and swallows (a persistence failure must never break playback),
+/// and a silent `catch` in BOTH places would make a dead write channel
+/// invisible from a car logcat.
+Future<void> guardarUltimaEmisoraPersistida(
+  Emisora emisora, {
+  SharedPreferences? prefs,
+}) async {
+  final resueltas = prefs ?? await SharedPreferences.getInstance();
+  await resueltas.setString(claveUltimaEmisora, jsonEncode(emisora.toMap()));
+}
+
 /// Reads the persisted last-played station, or `null` when there is none,
 /// the payload is unreadable, or prefs themselves fail.
 Future<Emisora?> _ultimaEmisora({SharedPreferences? prefs}) async {