feat(j0.3): socle transverse (Result/Failure, theme, router, DI)

- core/error : Result<S> maison (Ok/Err) + Failure scellee avec egalite de valeur
- core/theme : AppTheme Material 3 (palette coucher, cibles tactiles enfant)
- core/router : routes nommees child/parentGate/parent (Navigator 1, placeholders)
- core/di : conventions providers
- CLAUDE.md §7 : Result maison & Navigator 1 actes (YAGNI)
- ROADMAP : 0.3 cochee, Jalon 0 termine
- corrections code review : egalite Failure, assertions tests, Map.unmodifiable

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

lib/core/error/failure.dart

@@ -0,0 +1,37 @@
+/// Types d'échec métier du domaine.
+///
+/// Les features ajoutent leurs propres sous-types en étendant [Failure].
+/// Les exceptions techniques (réseau, IO) sont capturées dans la couche data
+/// et converties en [Failure] avant de remonter.
+sealed class Failure {
+  const Failure(this.message);
+
+  final String message;
+
+  @override
+  bool operator ==(Object other) =>
+      other is Failure &&
+      other.runtimeType == runtimeType &&
+      other.message == message;
+
+  @override
+  int get hashCode => Object.hash(runtimeType, message);
+
+  @override
+  String toString() => '$runtimeType($message)';
+}
+
+/// Erreur de communication réseau (timeout, pas de connectivité, HTTP 5xx…).
+final class NetworkFailure extends Failure {
+  const NetworkFailure(super.message);
+}
+
+/// Ressource demandée introuvable (HTTP 404, entité absente en base…).
+final class NotFoundFailure extends Failure {
+  const NotFoundFailure(super.message);
+}
+
+/// Erreur inattendue non catégorisée — à affiner si elle se répète.
+final class UnexpectedFailure extends Failure {
+  const UnexpectedFailure(super.message);
+}

lib/core/error/result.dart

@@ -0,0 +1,72 @@
+import 'package:storytime/core/error/failure.dart';
+
+/// Résultat d'une opération qui peut échouer.
+///
+/// - [Ok] : succès avec une valeur de type [S].
+/// - [Err] : échec avec un [Failure] typé.
+///
+/// Utilisé par les use cases pour renvoyer succès ou erreur sans lever
+/// d'exception à travers les couches.
+sealed class Result<S> {
+  const Result();
+
+  /// Transforme la valeur en cas de succès ; laisse [Err] intact.
+  Result<T> map<T>(T Function(S value) transform) => switch (this) {
+    Ok<S>(:final value) => Ok<T>(transform(value)),
+    Err<S>(:final failure) => Err<T>(failure),
+  };
+
+  /// Réduit le résultat à une valeur unique en fournissant les deux branches.
+  T fold<T>({
+    required T Function(S value) onOk,
+    required T Function(Failure failure) onErr,
+  }) => switch (this) {
+    Ok<S>(:final value) => onOk(value),
+    Err<S>(:final failure) => onErr(failure),
+  };
+
+  /// Exécute un effet de bord selon la branche, sans retourner de valeur.
+  void when({
+    required void Function(S value) ok,
+    required void Function(Failure failure) err,
+  }) {
+    switch (this) {
+      case Ok<S>(:final value):
+        ok(value);
+      case Err<S>(:final failure):
+        err(failure);
+    }
+  }
+}
+
+/// Cas succès.
+final class Ok<S> extends Result<S> {
+  const Ok(this.value);
+
+  final S value;
+
+  @override
+  bool operator ==(Object other) => other is Ok<S> && other.value == value;
+
+  @override
+  int get hashCode => value.hashCode;
+
+  @override
+  String toString() => 'Ok($value)';
+}
+
+/// Cas échec.
+final class Err<S> extends Result<S> {
+  const Err(this.failure);
+
+  final Failure failure;
+
+  @override
+  bool operator ==(Object other) => other is Err<S> && other.failure == failure;
+
+  @override
+  int get hashCode => failure.hashCode;
+
+  @override
+  String toString() => 'Err($failure)';
+}