feat(paises): add country browser and extract shared radio transport

Extracts ServicioRadio's transport loop (server discovery, host rotation,
bounded retries, User-Agent, timeout, status check, json.decode, sticky-host
bookkeeping) out of `_get` into a new `_getJson(path, params) ->
Future<List<dynamic>>` helper, moved as one block with no logic edits. `_get`
is reimplemented on top, still owning every station-specific concern:
`lastcheckok: '1'`, `Emisora.fromApi` + the empty-uuid/url filter, and the
`_compararCalidad` quality sort. `_getJson` is deliberately sort-agnostic and
filter-agnostic so a non-station endpoint can reuse the resilience behaviour
without inheriting station-only semantics.

Non-negotiable ordering followed per design ADR-4: new
test/servicios/servicio_radio_transporte_test.dart characterises all 8
existing station calls (7 via `_get` plus `registrarClick`, which builds its
own URI) against the UNMODIFIED `_get` first - green by construction -
pinning path, lastcheckok=1, hidebroken=true, a non-empty User-Agent, exact
order/reverse/limit/offset, and the exact returned UUID sequence from a
fixture with deliberately shuffled bitrate/clickcount/votes. That last
assertion is what makes the extraction safe: a sort that silently sank into
transport would pass every other check. Re-running the same file after the
extraction is byte-identical green. test/servicios/servicio_radio_test.dart
is untouched by this work unit - its passing unmodified is itself a signal
that transport wasn't disturbed.

The 6 pre-existing `order: bitrate` occurrences (obtenerPopulares,
buscarPorNombre, buscarPorPais, buscarPorIdioma, buscarPorTag, buscar) are
untouched - a deliberate server-side quality bias deciding which stations
return within `limit`, unrelated to and never to be confused with the
user-facing "Ordenar" control, which stays entirely client-side via the
existing OrdenEmisoras (Engram reference/radio-browser-sort-order).

Behaviour delta, accepted per ADR-4, not a regression: moving
`_servidorActual` bookkeeping into `_getJson` means a successful
`/json/countries` call now warms the sticky host for subsequent station
calls too - one shared warm mirror per instance, desirable, not per-call-type
state.

Adds the Paises browser over the verified `/json/countries` contract (Engram
reference/radio-browser-countries-endpoint): new lib/modelos/pais_radio.dart
(`PaisRadio.fromApi` parses `stationcount` via `int.tryParse` since the API
returns it as a JSON string, not an int - an `as int` cast would throw),
`obtenerPaises()` sends neither `lastcheckok` nor `order` (the screen sorts
client-side by name; the API's raw byte order isn't proper collation for any
locale this app ships), and inherits `hidebroken=true` from the unchanged
`_uri` (desirable here too, since the endpoint's own default is false).
`EstadoBusqueda` gains `paises`/`cargandoPaises`/`cargarPaises()` with an
in-memory cache guard so re-entering the screen never refetches.

New PantallaPaises (lib/pantallas/pantalla_paises.dart): a "Tus idiomas"
shortlist (one representative country per the app's 13 supported locales,
matched against the fetched list - the proposal/spec name this section but
don't specify its derivation) above the full alphabetical list, each entry
showing its parsed station count. Reachable from Buscar's discovery landing
state via a new entry row, added now rather than left dangling per this
file's own forward-reference comment (and the WU15/WU15b lesson: a
fully-tested but unreachable screen is a real defect, not a follow-up).

New ARB keys (en/es only, matching this change's established precedent):
countriesScreenTitle, countriesYourLanguagesTitle, countriesAllTitle,
radioCountriesError.

Tests: 631 -> 649 (2 skipped, unchanged). flutter analyze unchanged at 1
pre-existing info. grep confirms `countrycodes` appears nowhere in lib/.

lib/estado/estado_busqueda.dart

@@ -6,6 +6,7 @@ import 'package:geolocator/geolocator.dart';
 
 import '../l10n/gen/app_localizations.dart';
 import '../modelos/emisora.dart';
+import '../modelos/pais_radio.dart';
 import '../servicios/servicio_radio.dart';
 import 'orden_emisoras.dart';
 
@@ -50,6 +51,8 @@ class EstadoBusqueda extends ChangeNotifier {
   String? _ultimoIdioma;
   String? _ultimoTag;
   int? _ultimoMinBitrate;
+  List<PaisRadio> _paises = [];
+  bool _cargandoPaises = false;
 
   final _memoResultados = MemoLista<Emisora>();
   final _memoCercanas = MemoLista<Emisora>();
@@ -68,6 +71,8 @@ class EstadoBusqueda extends ChangeNotifier {
   bool get cargandoCercanas => _cargandoCercanas;
   String? get paisCercanoDetectado => _paisCercanoDetectado;
   String? get errorCercanas => _errorCercanas;
+  List<PaisRadio> get paises => _paises;
+  bool get cargandoPaises => _cargandoPaises;
 
   /// Re-renders sorted views after the user changes the list ordering
   /// (called by EstadoRadio, which owns that preference).
@@ -219,4 +224,33 @@ class EstadoBusqueda extends ChangeNotifier {
       notifyListeners();
     }
   }
+
+  /// Fetches the Países browser's country list (WU7, `station-discovery-browse`
+  /// spec). In-memory cache guard: once populated, re-entering the screen
+  /// does not refetch — this is deliberately NOT time-based invalidation,
+  /// since the country/station-count universe changes on a scale of days,
+  /// not per app session.
+  ///
+  /// Sorted once here (case-insensitive by name, same convention as
+  /// `ordenarEmisoras`'s `OrdenEmisoras.nombre` case) since the API orders by
+  /// raw byte order, not proper collation (design ADR-4).
+  Future<void> cargarPaises() async {
+    if (_paises.isNotEmpty || _cargandoPaises) return;
+    _cargandoPaises = true;
+    notifyListeners();
+    try {
+      // Defensive copy: `radio.obtenerPaises()` makes no growable/mutable
+      // guarantee about the list it returns (tests may hand back a `const`
+      // list) — sorting in place would throw on an unmodifiable list.
+      final ordenados = List<PaisRadio>.of(await radio.obtenerPaises())..sort(
+        (a, b) => a.nombre.toLowerCase().compareTo(b.nombre.toLowerCase()),
+      );
+      _paises = ordenados;
+    } catch (_) {
+      _alError?.call(_textos().radioCountriesError);
+    } finally {
+      _cargandoPaises = false;
+      notifyListeners();
+    }
+  }
 }