feat(studio): trust pass — friendly errors + store clarity + MCP i18n

Second half of the May-2026 trust pass. Drops the wall of
gRPC trailers from every error surface and makes the Store
honest about what is and isn't installable.

Friendly errors:

- New `friendlyError(Object, AppLocalizations)` mapper turns
  GrpcError + arbitrary throwables into a localised headline,
  optional recovery hint, and a verbatim detail string kept
  behind a "Show details" expander. Duck-typed on `.code` /
  `.message` so Studio doesn't have to depend on package:grpc
  directly.
- `FaiErrorBox` gains an `error:` constructor that runs the
  mapper. Every call site that used to render
  `snap.error.toString()` (flows, welcome, store) switches to
  it.
- 9 .arb entries per locale cover the gRPC codes we actually
  emit (INVALID_ARGUMENT, NOT_FOUND, ALREADY_EXISTS,
  PERMISSION_DENIED, FAILED_PRECONDITION, INTERNAL,
  UNAVAILABLE, UNAUTHENTICATED) plus copy/details affordances.
- `test/friendly_error_test.dart` — 6 unit tests for the
  mapper. Covers the mapping table, locale-switching, and the
  non-gRPC fallback so future regressions show up in CI.

Capability discovery:

- New `HubService.allCapabilities()` reads the kind-aware
  capability list (wasm + builtin + federated) and returns a
  Dart-side `CapabilityInfo` value type. The flow page's
  missing-dependency check uses it so `system.approval` and
  federated MCP/n8n tools count as "available" — fixes the
  Run button staying disabled forever.
- `HubService.listModules()` filters to kind=wasm so the
  Modules page doesn't sprout synthetic "system" entries that
  the operator can't uninstall.

Store clarity:

- New "Installable only" filter, on by default. Roughly 2/3
  of seed entries currently carry `status: planned`; the
  default view stops being noise.
- Featured-strip cards for planned modules now show a
  "Coming soon" pill instead of an empty action area.
- Main-grid cards for non-installable modules dim to 60%
  opacity so the eye lands on actionable cards first.
- Detail-sheet "Nicht installierbar" tooltip → inline hint
  box. The reason is visible without hovering.

MCP localisation:

- `_kMcpSuggestions` no longer holds 11 hardcoded English
  description strings. The `description` field is replaced
  with a `resolveDescription(AppLocalizations)` lookup that
  switches on the suggestion `name` to read the matching
  `mcpSuggestion*Desc` .arb key. EN + DE shipped.
- New `FaiEnBadge` widget renders a small `[EN]` pill when
  the active locale isn't English. Used next to MCP /
  federated store entries' tagline + description because
  the server supplies them in English and we can't translate
  on the fly yet — the badge is the honest signal until the
  planned `studio.translate` plugin lands.

Plus housekeeping: removed the unused `_keepImport` lint
escape in the test and the dangling library doc-comment in
`format.dart`.

Signed-off-by: flemming-it <sf@flemming.it>
Signed-off-by: flemming-it <stefan.a.flemming@googlemail.com>

test/friendly_error_test.dart

@@ -0,0 +1,84 @@
+// Unit tests for the `friendlyError` mapper. These check the
+// duck-typed shape contract — `GrpcError` from package:grpc is
+// expected to expose `.code` (int), `.message` (String?), and
+// `.codeName` (String) — without taking grpc as a Studio
+// dependency. The fakes here mimic that shape.
+
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:fai_studio/data/friendly_error.dart';
+import 'package:fai_studio/l10n/app_localizations.dart';
+
+class _FakeGrpcError {
+  final int code;
+  final String? message;
+  final String codeName;
+  _FakeGrpcError(this.code, this.codeName, [this.message]);
+}
+
+Future<AppLocalizations> _loadL10n(Locale locale) async {
+  return await AppLocalizations.delegate.load(locale);
+}
+
+void main() {
+  WidgetsFlutterBinding.ensureInitialized();
+  setUpAll(() async {
+    // Force loading the gen-l10n delegate before tests so each
+    // call to `_loadL10n` is fast.
+    await _loadL10n(const Locale('en'));
+  });
+
+  test('UNAVAILABLE maps to hub-not-reachable copy', () async {
+    final l = await _loadL10n(const Locale('en'));
+    final r = friendlyError(_FakeGrpcError(14, 'UNAVAILABLE', 'connection refused'), l);
+    expect(r.headline, l.errUnavailable);
+    expect(r.hint, l.errUnavailableHint);
+    expect(r.detail, 'connection refused');
+  });
+
+  test('FAILED_PRECONDITION carries module detail in body', () async {
+    final l = await _loadL10n(const Locale('en'));
+    final r = friendlyError(
+      _FakeGrpcError(9, 'FAILED_PRECONDITION',
+          'install error: no store entry for system.approval'),
+      l,
+    );
+    expect(r.headline, l.errFailedPrecondition);
+    expect(r.hint, l.errFailedPreconditionHint);
+    expect(r.detail, contains('system.approval'));
+  });
+
+  test('NOT_FOUND has a recovery hint', () async {
+    final l = await _loadL10n(const Locale('en'));
+    final r = friendlyError(_FakeGrpcError(5, 'NOT_FOUND', 'no such module'), l);
+    expect(r.headline, l.errNotFound);
+    expect(r.hint, isNotNull);
+  });
+
+  test('Unknown code falls back to codeName: message', () async {
+    final l = await _loadL10n(const Locale('en'));
+    final r = friendlyError(_FakeGrpcError(99, 'CUSTOM_CODE', 'something'), l);
+    expect(r.headline, contains('CUSTOM_CODE'));
+    expect(r.headline, contains('something'));
+    expect(r.hint, isNull);
+  });
+
+  test('Non-gRPC error renders toString as headline', () async {
+    final l = await _loadL10n(const Locale('en'));
+    final r = friendlyError(FormatException('bad url'), l);
+    expect(r.headline, contains('bad url'));
+  });
+
+  test('Locale switches the headline language', () async {
+    final lDe = await _loadL10n(const Locale('de'));
+    final r =
+        friendlyError(_FakeGrpcError(14, 'UNAVAILABLE', 'connection refused'), lDe);
+    expect(r.headline, lDe.errUnavailable);
+    // Sanity: the DE headline really is different from the EN
+    // one — guards against the test silently passing if l10n
+    // regen returned EN for both.
+    final lEn = await _loadL10n(const Locale('en'));
+    expect(lDe.errUnavailable, isNot(equals(lEn.errUnavailable)));
+  });
+}
+