feat(inventory): auto-recover from a transient stream failure

Instead of showing a retry button on the first failure, silently re-open
the inventory stream with exponential backoff (250ms→4s, 6 attempts,
staying in the loading spinner). The startup DB-not-ready race clears in
well under a second, so the user just sees the spinner briefly and the
list appears — no tap needed. Only after the retry budget is exhausted do
we surface the manual-retry error.

Tests cover auto-recovery, no error flicker during retries, and the
give-up path (via fake_async to fast-forward the backoff).

apps/app_seeds/test/state/inventory_cubit_test.dart

@@ -1,6 +1,7 @@
 import 'dart:typed_data';
 
 import 'package:commons_core/commons_core.dart';
+import 'package:fake_async/fake_async.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:tane/data/variety_repository.dart';
 import 'package:tane/db/database.dart';
@@ -9,20 +10,23 @@ import 'package:tane/state/inventory_cubit.dart';
 
 import '../support/test_support.dart';
 
-/// A repository whose inventory stream errors until [healthy] is flipped —
-/// mimics the transient DB-not-ready failure that used to leave the spinner
-/// stuck forever.
+/// A repository whose inventory stream errors for the first
+/// [failuresBeforeHealthy] subscriptions, then behaves normally — mimics the
+/// transient DB-not-ready failure that used to leave the spinner stuck forever.
+/// The default never recovers, for the "give up" path.
 class _FailingRepository extends VarietyRepository {
   // ignore: use_super_parameters
-  _FailingRepository(AppDatabase db)
+  _FailingRepository(AppDatabase db, {this.failuresBeforeHealthy = 1 << 30})
     : super(db, idGen: IdGen(), nodeId: 'test-node');
 
-  bool healthy = false;
+  final int failuresBeforeHealthy;
+  int subscriptions = 0;
 
   @override
   Stream<({List<VarietyListItem> items, List<VarietyListItem> drafts})>
-  watchInventoryView() =>
-      healthy ? super.watchInventoryView() : Stream.error(StateError('boom'));
+  watchInventoryView() => subscriptions++ < failuresBeforeHealthy
+      ? Stream.error(StateError('boom'))
+      : super.watchInventoryView();
 }
 
 /// Waits until the cubit's state satisfies [predicate], whether it already
@@ -57,30 +61,49 @@ void main() {
   });
 
   group('stream failure', () {
-    test('a failing stream drops loading and surfaces an error, not a '
-        'forever-spinner', () async {
-      final failing = _FailingRepository(db);
+    test('a transient failure recovers on its own — no error, no manual retry',
+        () async {
+      // Fails the first two subscribes, then the DB is ready.
+      final failing = _FailingRepository(db, failuresBeforeHealthy: 2);
+      await failing.addQuickVariety(label: 'Maize');
       final failCubit = InventoryCubit(failing);
       addTearDown(failCubit.close);
 
-      final state = await waitFor(failCubit, (s) => s.error != null);
-      expect(state.loading, isFalse);
-      expect(state.error, contains('boom'));
+      // Auto-retry with backoff brings it back without ever showing an error.
+      final state = await waitFor(failCubit, (s) => !s.loading && s.error == null);
+      expect(state.items.single.label, 'Maize');
+      expect(failing.subscriptions, greaterThan(1));
     });
 
-    test('retry re-opens the stream and recovers once the DB is healthy',
+    test('stays in loading (spinner), never flips to error, while auto-retrying',
         () async {
-      final failing = _FailingRepository(db);
+      final failing = _FailingRepository(db, failuresBeforeHealthy: 2);
+      await failing.addQuickVariety(label: 'Maize');
       final failCubit = InventoryCubit(failing);
       addTearDown(failCubit.close);
-      await waitFor(failCubit, (s) => s.error != null);
 
-      await failing.addQuickVariety(label: 'Maize');
-      failing.healthy = true;
-      failCubit.retry();
+      final errors = <String?>[];
+      final sub = failCubit.stream.listen((s) => errors.add(s.error));
+      addTearDown(sub.cancel);
 
-      final state = await waitFor(failCubit, (s) => s.error == null && !s.loading);
-      expect(state.items.single.label, 'Maize');
+      await waitFor(failCubit, (s) => !s.loading && s.error == null);
+      expect(errors.every((e) => e == null), isTrue,
+          reason: 'no error state should be emitted during auto-recovery');
+    });
+
+    test('gives up after the retry budget and surfaces a manual-retry error',
+        () {
+      fakeAsync((async) {
+        final failing = _FailingRepository(db); // never recovers
+        final failCubit = InventoryCubit(failing);
+        addTearDown(failCubit.close);
+
+        // Fast-forward past all backoff windows (~12s of retries).
+        async.elapse(const Duration(seconds: 30));
+
+        expect(failCubit.state.loading, isFalse);
+        expect(failCubit.state.error, contains('boom'));
+      });
     });
   });