core-locale: locale-aware date formatting (currentLocale, localizedDateFormatter)

Both functions lived in Calendula's ui/common/LocaleSupport.kt. Neither is
calendar-specific — "lay this date out the way this language writes dates" is
family plumbing — so they move here, where Agendula can reach them too.

localizedDateFormatter(locale, skeleton) takes a field list ("LLLLy", "dMMMy")
and lets the locale arrange it, which is the only way to render a date correctly
in a language you didn't hand-write a template for. Dropping a field from the
skeleton drops it from the output, so callers ask for "no year" by omitting it
rather than post-processing a longer pattern.

currentLocale() reads the display locale from LocalConfiguration. This module's
own AppLanguage.apply() changes the language inside a running process, so a
locale captured once goes stale; keying on the configuration makes the UI follow
the switch.

core-locale gains Compose (runtime + ui only) for currentLocale(). Its build file
previously declared itself Compose-free, but the alternative — parking the hook
in a Compose module that depends back on this one — splits one concern across two
modules to honour a comment. core-crash is the precedent for a core-* module
carrying Compose.

Leaves core-time's Instant.formatDate() family alone despite the overlap: it is
unused by Calendula but visible to Agendula, so reconciling it is that app's
call, not a drive-by here. Noted in the changelog.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/DateFormatting.kt

@@ -0,0 +1,33 @@
+package de.jeanlucmakiola.floret.locale
+
+import java.time.format.DateTimeFormatter
+import java.util.Locale
+
+/**
+ * A [DateTimeFormatter] for [skeleton]'s fields laid out in [locale]'s own order,
+ * via Android's best-pattern matching.
+ *
+ * A skeleton lists the *fields* you want, not their arrangement: "dMMMy" asks for
+ * day, abbreviated month and year, and the locale decides that en-US renders
+ * "Jul 17, 2026" while de-DE renders "17. Juli 2026". Hand-rolled templates like
+ * `"$day. $month $year"` can't do this — they bake one locale's order (and its
+ * separators, and its ordinal dot) into every language the app ships.
+ *
+ * Drop a field to drop it from the output: "dMMM" is the same date without the
+ * year, still in the locale's order. Prefer that over post-processing a longer
+ * pattern, which cannot know which separators belonged to the removed field.
+ *
+ * Common skeletons: "LLLLy" (standalone month + year), "dMMMy" (day, month, year),
+ * "EEEdMMM" (weekday too). [locale] should come from [currentLocale] in Compose,
+ * so formatting follows an in-process language change.
+ *
+ * NB: this delegates to `android.text.format.DateFormat`, so it needs a real
+ * Android runtime — under unit tests with `isReturnDefaultValues` it yields no
+ * pattern. Test the skeleton *choice* in your own code; the layout itself is ICU's
+ * job and is not worth mocking.
+ */
+fun localizedDateFormatter(locale: Locale, skeleton: String): DateTimeFormatter =
+    DateTimeFormatter.ofPattern(
+        android.text.format.DateFormat.getBestDateTimePattern(locale, skeleton),
+        locale,
+    )

core-locale/src/main/kotlin/de/jeanlucmakiola/floret/locale/LocaleCompose.kt

@@ -0,0 +1,26 @@
+package de.jeanlucmakiola.floret.locale
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.core.os.ConfigurationCompat
+import java.util.Locale
+
+/**
+ * The current display [Locale], read observably from [LocalConfiguration].
+ *
+ * Use this rather than [Locale.getDefault] anywhere a composable formats a date,
+ * a name or a number. [AppLanguage.apply] changes the language inside a running
+ * process, so a locale captured once — in a `val`, a top-level formatter, or a
+ * `remember {}` with no key — goes stale and keeps rendering the old language.
+ * Reading through [LocalConfiguration] keys recomposition to the configuration,
+ * so the UI follows the switch. (Android lint flags the alternative as
+ * NonObservableLocale.)
+ */
+@Composable
+fun currentLocale(): Locale {
+    val configuration = LocalConfiguration.current
+    return remember(configuration) {
+        ConfigurationCompat.getLocales(configuration).get(0) ?: Locale.getDefault()
+    }
+}