i18n: ship the UI in English and German

The last open item on the M7 list. Number and currency formatting was
already locale-aware, but every string in the UI was an English literal,
so a German instance read half in each language -- German data, English
chrome. This translates all of it and adds the machinery to keep it
translated.

Strings live in Localization/Strings.resx (English, neutral) and
Strings.de.resx. The neutral file generates a strongly-typed accessor at
build time, aliased as S in _Imports.razor, so components reference
compiled properties -- @S.Common_Save, not a string key. That choice is
the point: across 4,500 lines of markup, a key lookup that silently
falls back to its own name is a defect you find in production, while a
renamed property is a build error. Generation runs in MSBuild rather
than the IDE designer, so dotnet build alone reproduces it anywhere.

Resource fallback is the hazard here. Ask for a key the German satellite
lacks and ResourceManager quietly serves the English one -- correct at
runtime, disastrous at release time, because a half-translated build
looks perfectly healthy. StringResourceTests reads each satellite with
tryParents: false, which is the only way to see what one actually
contains, and fails on a missing or blank translation, a placeholder
that changed arity, an orphan, or a key nothing references.

Three things needed more than substitution:

- Domain enums reached the screen as bare identifiers. They stay bare in
  the model -- they are persisted as text and appear in the REST API, so
  their names are part of the data contract -- and DisplayNames is now
  the single place that decides how each value is spoken. Every arm ends
  in a fallback returning the identifier, so a value added later cannot
  throw mid-render; EnumDisplayNameTests is what stops that safety net
  quietly becoming the shipping behaviour.

- Infrastructure was writing display text: FlowService's "Other (X)",
  MeterPeriodView's "Generation"/"Consumption", the HA connection-test
  verdicts, the updater's snackbar, the CSV importer's row warnings.
  Each now returns an outcome value and the UI supplies the words, which
  is where the reader's language is known. Diagnostics that are not ours
  -- an HTTP status, systemd's stderr, an exception message -- are passed
  through untranslated, and every English summary is kept alongside the
  outcome so log lines never move with the UI language. The UpdateRunner
  change is additive only; no gate was touched.

- Importer warnings carry their arguments rather than a finished
  sentence, so the numbers inside them pick up the reader's grouping. A
  register that reads 2.940,19 everywhere else must not read 2940.19
  only inside a warning.

Switching language is a redirect through /culture/set followed by a full
reload, not an interactive state change: a Blazor Server circuit is fixed
to the culture of the request that opened it. That makes the endpoint a
redirector taking its target from the query string, so anything but a
local path is refused rather than followed. Preference order is the
cookie, then Accept-Language, then MeterVault__Locale -- an instance can
be pinned to one language and a reader can still switch.

Locale keeps its documented default of "en". Format now follows
CurrentCulture instead of a hardcoded de-DE, so an instance with nothing
configured and a browser asking for English will show English number
formatting where it previously showed German; set MeterVault__Locale=de
to pin the old behaviour. The importer's de-DE parsing is untouched and
stays that way -- that dialect is a property of the spreadsheets, not of
whoever is looking at the dashboard.

Anything that comes from the database -- meter names, energy-type display
names, category names -- is user data and is never translated.

Claude-Session: https://claude.ai/code/session_0112ezeWqaZ85kTj5bYu9JHx

tests/Integration.Tests/DashboardRenderTests.cs

@@ -2,6 +2,7 @@ using MeterVault.Infrastructure.Costing;
 using MeterVault.Infrastructure.Dashboard;
 using MeterVault.Infrastructure.Import;
 using MeterVault.Infrastructure.Persistence;
+using Microsoft.AspNetCore.Localization;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -111,6 +112,45 @@ public sealed class DashboardRenderTests(TimescaleFixture fx)
             var meterPage = await (await client.GetAsync(new Uri($"/meters/{hausId}", UriKind.Relative)))
                 .Content.ReadAsStringAsync();
             Assert.Contains("Add reading", meterPage, StringComparison.Ordinal);
+
+            // The same pages in German (SDD §12, M7). Real data rather than an empty instance, so
+            // this covers the labels that only exist once rows have rendered — the branch a
+            // smoke test against a bare database silently skips.
+            using var germanClient = factory.CreateClient();
+            germanClient.DefaultRequestHeaders.Add(
+                "Cookie",
+                CookieRequestCultureProvider.DefaultCookieName
+                + "="
+                + Uri.EscapeDataString(CookieRequestCultureProvider.MakeCookieValue(new RequestCulture("de"))));
+
+            // Decoded, because Blazor entity-encodes non-ASCII: "Übersicht" ships as "Übersicht".
+            var germanOverview = System.Net.WebUtility.HtmlDecode(
+                await germanClient.GetStringAsync(new Uri("/", UriKind.Relative)));
+            Assert.Contains("lang=\"de\"", germanOverview, StringComparison.Ordinal);
+            Assert.Contains("Übersicht", germanOverview, StringComparison.Ordinal);
+            Assert.DoesNotContain("This month", germanOverview, StringComparison.Ordinal);
+            Assert.DoesNotContain("Latest month with data", germanOverview, StringComparison.Ordinal);
+
+            // Meter names are user data: they stay exactly as imported, in either language. The
+            // meter list is where they render — the overview shows cost categories, not meters.
+            var germanMeters = System.Net.WebUtility.HtmlDecode(
+                await germanClient.GetStringAsync(new Uri("/meters", UriKind.Relative)));
+            Assert.Contains("Zähler Haus", germanMeters, StringComparison.Ordinal);
+            // ...while the meter's mode, which is an enum and not user data, is translated.
+            Assert.Contains("Zählerstand (kumulativ)", germanMeters, StringComparison.Ordinal);
+            Assert.DoesNotContain("CumulativeCounter", germanMeters, StringComparison.Ordinal);
+
+            foreach (var path in new[]
+            {
+                "/meters", "/trends", "/solar", "/consumables", "/import",
+                "/admin/tariffs", "/admin/energy-types", "/admin/categories",
+                "/admin/connectors", "/admin/settings", $"/meters/{hausId}",
+                $"/energy/{electricityTypeId}",
+            })
+            {
+                var response = await germanClient.GetAsync(new Uri(path, UriKind.Relative));
+                response.EnsureSuccessStatusCode();
+            }
         }
         finally
         {