feat(gestion): suppression en cascade exercice/programme/séance-modèle (ticket #37)

Ajoute la suppression avec gestion des dépendances en cascade sur les
écrans bibliothèque d'exercices, programme et séance-modèle, avec les
use cases et le bootstrap applicatif associés. flutter analyze propre,
58/58 tests verts, build APK debug validé.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

lib/application/use_cases.dart

@@ -8,12 +8,14 @@ const Object _useCaseUnchanged = Object();
 final class ExerciseUseCases {
   const ExerciseUseCases({
     required this.repository,
+    required this.programRepository,
     required this.clock,
     required this.ids,
     required this.originDeviceId,
   });
 
   final ExerciseRepository repository;
+  final ProgramRepository programRepository;
   final Clock clock;
   final IdGenerator ids;
   final String originDeviceId;
@@ -181,6 +183,35 @@ final class ExerciseUseCases {
     await repository.save(archived);
     return archived;
   }
+
+  Future<Exercise> delete(String id) async {
+    final exercise = await repository.findById(id);
+    if (exercise == null) {
+      throw const DomainException('Exercise not found.');
+    }
+    final now = clock.now();
+    final deleted = exercise.copyWith(
+      metadata: exercise.metadata.markDeleted(now),
+    );
+    final programs = await programRepository.listActive();
+    for (final program in programs) {
+      final keptExercises = program.exercises
+          .where((programExercise) => programExercise.sourceExerciseId != id)
+          .toList();
+      if (keptExercises.length == program.exercises.length) {
+        continue;
+      }
+      await programRepository.replaceExercises(
+        program.copyWith(
+          metadata: program.metadata.touch(now),
+          exercises: _repositionProgramExercises(keptExercises, now),
+        ),
+        now,
+      );
+    }
+    await repository.save(deleted);
+    return deleted;
+  }
 }
 
 final class MediaUseCases {
@@ -272,6 +303,7 @@ final class ProgramUseCases {
   const ProgramUseCases({
     required this.programRepository,
     required this.exerciseRepository,
+    required this.templateRepository,
     required this.clock,
     required this.ids,
     required this.originDeviceId,
@@ -279,6 +311,7 @@ final class ProgramUseCases {
 
   final ProgramRepository programRepository;
   final ExerciseRepository exerciseRepository;
+  final WorkoutTemplateRepository templateRepository;
   final Clock clock;
   final IdGenerator ids;
   final String originDeviceId;
@@ -287,6 +320,14 @@ final class ProgramUseCases {
 
   Future<List<Program>> listActive() => programRepository.listActive();
 
+  Future<bool> isUsedInWorkoutTemplates(String id) async {
+    final templates = await templateRepository.listActive();
+    return templates.any(
+      (template) =>
+          template.programs.any((program) => program.sourceProgramId == id),
+    );
+  }
+
   Future<Program> create({
     required String name,
     required int defaultRestSeconds,
@@ -399,6 +440,50 @@ final class ProgramUseCases {
     await programRepository.saveExercise(programExercise);
     return programExercise;
   }
+
+  Future<Program> delete(String id) async {
+    final program = await programRepository.findById(id);
+    if (program == null) {
+      throw const DomainException('Program not found.');
+    }
+    final now = clock.now();
+    final deleted = program.copyWith(
+      metadata: program.metadata.markDeleted(now),
+    );
+    final templates = await templateRepository.listActive();
+    for (final template in templates) {
+      final keptPrograms = template.programs
+          .where((templateProgram) => templateProgram.sourceProgramId != id)
+          .toList();
+      if (keptPrograms.length == template.programs.length) {
+        continue;
+      }
+      final repositionedPrograms = _repositionWorkoutTemplatePrograms(
+        keptPrograms,
+        now,
+      );
+      final keptProgramIds = repositionedPrograms
+          .map((templateProgram) => templateProgram.metadata.id)
+          .toSet();
+      await templateRepository.replaceComposition(
+        WorkoutTemplate(
+          metadata: template.metadata.touch(now),
+          name: template.name,
+          lastStartedAt: template.lastStartedAt,
+          programs: repositionedPrograms,
+          overrides: template.overrides
+              .where(
+                (override) =>
+                    keptProgramIds.contains(override.workoutTemplateProgramId),
+              )
+              .toList(),
+        ),
+        now,
+      );
+    }
+    await programRepository.save(deleted);
+    return deleted;
+  }
 }
 
 final class ProgramExerciseConfig {
@@ -608,6 +693,21 @@ final class WorkoutTemplateUseCases {
     await templateRepository.saveOverride(override);
     return override;
   }
+
+  Future<WorkoutTemplate> delete(String id) async {
+    final template = await templateRepository.findById(id);
+    if (template == null) {
+      throw const DomainException('Workout template not found.');
+    }
+    final now = clock.now();
+    final deleted = WorkoutTemplate(
+      metadata: template.metadata.markDeleted(now),
+      name: template.name,
+      lastStartedAt: template.lastStartedAt,
+    );
+    await templateRepository.save(deleted);
+    return deleted;
+  }
 }
 
 final class WorkoutTemplateProgramConfig {
@@ -1323,6 +1423,62 @@ final class SetResultPositionState {
   final ActiveSetResult? result;
 }
 
+List<ProgramExercise> _repositionProgramExercises(
+  List<ProgramExercise> exercises,
+  DateTime now,
+) {
+  return [
+    for (var index = 0; index < exercises.length; index++)
+      ProgramExercise(
+        metadata: exercises[index].metadata.touch(now),
+        programId: exercises[index].programId,
+        sourceExerciseId: exercises[index].sourceExerciseId,
+        position: index,
+        exerciseNameSnapshot: exercises[index].exerciseNameSnapshot,
+        exerciseDescriptionSnapshot:
+            exercises[index].exerciseDescriptionSnapshot,
+        exerciseImageMediaIdSnapshot:
+            exercises[index].exerciseImageMediaIdSnapshot,
+        exerciseVideoMediaIdSnapshot:
+            exercises[index].exerciseVideoMediaIdSnapshot,
+        exerciseArchivedSnapshot: exercises[index].exerciseArchivedSnapshot,
+        availableTimeSnapshot: exercises[index].availableTimeSnapshot,
+        availableRepsSnapshot: exercises[index].availableRepsSnapshot,
+        availableScoreSnapshot: exercises[index].availableScoreSnapshot,
+        scoreInputModeSnapshot: exercises[index].scoreInputModeSnapshot,
+        scoreLabelSnapshot: exercises[index].scoreLabelSnapshot,
+        scoreUnitSnapshot: exercises[index].scoreUnitSnapshot,
+        setsCount: exercises[index].setsCount,
+        timeEnabled: exercises[index].timeEnabled,
+        repsEnabled: exercises[index].repsEnabled,
+        scoreEnabled: exercises[index].scoreEnabled,
+        targetTimeSeconds: exercises[index].targetTimeSeconds,
+        targetReps: exercises[index].targetReps,
+        targetScore: exercises[index].targetScore,
+        targetScoreTimeMs: exercises[index].targetScoreTimeMs,
+        restSecondsOverride: exercises[index].restSecondsOverride,
+      ),
+  ];
+}
+
+List<WorkoutTemplateProgram> _repositionWorkoutTemplatePrograms(
+  List<WorkoutTemplateProgram> programs,
+  DateTime now,
+) {
+  return [
+    for (var index = 0; index < programs.length; index++)
+      WorkoutTemplateProgram(
+        metadata: programs[index].metadata.touch(now),
+        workoutTemplateId: programs[index].workoutTemplateId,
+        sourceProgramId: programs[index].sourceProgramId,
+        position: index,
+        programNameSnapshot: programs[index].programNameSnapshot,
+        defaultRestSecondsSnapshot: programs[index].defaultRestSecondsSnapshot,
+        programSnapshotJson: programs[index].programSnapshotJson,
+      ),
+  ];
+}
+
 void _validateExerciseDefaultTargets({
   required bool hasTimeMeasure,
   required bool hasRepsMeasure,