Resolve "EU" through platform locale data instead of hardcoding it

Verified directly (java.util.Locale, NSLocale, and Intl.DisplayNames
all tested outside the app) that every platform's locale data resolves
"EU" correctly on its own — "European Union" in en, "Union européenne"
in fr, "Europäische Union" in de, etc. — via CLDR, which defines "EU"
as a grouping in its own right despite it not being a real ISO 3166-1
country code. The hardcoded English fallback was based on an
assumption that was never actually verified.

Removes the special case from the shared code entirely. That required
two platform-side fixes to stop blocking "EU" from ever reaching the
platform lookup:
- JVM/Android: dropped the Locale.getISOCountries() membership guard
  (which excluded "EU") in favor of detecting an unresolvable code by
  getDisplayCountry() echoing it back unchanged.
- Web: jsRegionDisplayName() was hardcoding locale 'en' for
  Intl.DisplayNames — changed to undefined (the browser's own locale),
  matching what the other platforms already did. Without this fix,
  "EU" would resolve, but only ever in English on web.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FXcrACM5sok3M1KQJ8kByy

shared/src/commonMain/kotlin/xyz/tyiu/satsprice/SystemCurrencies.kt

@@ -13,7 +13,7 @@ fun matchesCurrencySearch(info: CurrencyInfo, query: String): Boolean {
     if (info.code.contains(query, ignoreCase = true)) return true
     if (info.displayName.contains(query, ignoreCase = true)) return true
     return issuingCountryCodes(info.code).any { regionCode ->
-        localizedRegionName(regionCode)?.contains(query, ignoreCase = true) == true
+        cachedRegionDisplayName(regionCode)?.contains(query, ignoreCase = true) == true
     }
 }
 
@@ -24,20 +24,20 @@ fun matchesCurrencySearch(info: CurrencyInfo, query: String): Boolean {
 // being retried every time, which getOrPut would do for a null value.
 private val regionDisplayNameCache = mutableMapOf<String, String?>()
 
-/**
- * A localized display name for ISO 3166-1 alpha-2 [regionCode] (e.g. "Canada"), or null if the
- * platform doesn't recognize it. "EU" is handled directly since it's not a real ISO 3166-1
- * country code — it's [issuingCountryCodes]' own stand-in for EUR's region/flag — and platform
- * locale data doesn't reliably resolve it to a name the way it does real country codes.
- */
-private fun localizedRegionName(regionCode: String): String? {
+private fun cachedRegionDisplayName(regionCode: String): String? {
     if (regionCode in regionDisplayNameCache) return regionDisplayNameCache[regionCode]
-    val name = if (regionCode == "EU") "European Union" else regionDisplayName(regionCode)
+    val name = regionDisplayName(regionCode)
     regionDisplayNameCache[regionCode] = name
     return name
 }
 
-/** The current platform's localized display name for ISO 3166-1 alpha-2 [regionCode], if known. */
+/**
+ * The current platform's localized display name for ISO 3166-1 alpha-2 [regionCode], if known.
+ * Also handles "EU" — [issuingCountryCodes]' own stand-in for EUR's region/flag, and not a real
+ * ISO 3166-1 code — since every platform's locale data resolves it correctly regardless (e.g.
+ * "European Union" in en, "Union européenne" in fr): CLDR, which all of their locale data is
+ * ultimately sourced from, defines "EU" as a grouping in its own right.
+ */
 expect fun regionDisplayName(regionCode: String): String?
 
 /**
@@ -52,7 +52,7 @@ fun warmRegionDisplayNameCache(currencies: List<CurrencyInfo>) {
     currencies.asSequence()
         .flatMap { issuingCountryCodes(it.code).asSequence() }
         .distinct()
-        .forEach { regionCode -> localizedRegionName(regionCode) }
+        .forEach { regionCode -> cachedRegionDisplayName(regionCode) }
 }
 
 /**