Remove all remaining bloat from testing documentation

Removed 220+ lines of generic testing content and framework behavior:

**Removed sections:**
- Testing with fake_async (generic timing control)
- Testing Disposal (framework behavior)
- Integration Testing (generic integration patterns)
- Common Testing Patterns (generic setUp/tearDown, framework behavior)
- Debugging Tests (generic debugging)
- Best Practices (outdated, referenced removed sections)

**Final focused structure:**
- Why Commands Are Easy to Test
- Basic Testing Pattern
- The Collector Pattern (observe-not-await philosophy)
- Testing Async Commands (runAsync convenience)
- Testing Error Handling (ErrorFilters)
- MockCommand (command_it-specific mocking tool)

Documentation now exclusively covers command_it-specific testing tools
and patterns. No generic Flutter/Dart tutorials or framework verification.

Total removed in testing review: 400+ lines of bloat.

Author: escamoteur

docs/documentation/command_it/testing.md

@@ -238,280 +238,6 @@ test('UI shows error message', () {
 - Unit testing command-dependent code
 - When you need precise control over command state transitions
 
-## Testing with fake_async
-
-For precise timing control, use `fake_async`:
-
-```dart
-import 'package:fake_async/fake_async.dart';
-
-test('Test with controlled time', () {
-  fakeAsync((async) {
-    var result = '';
-
-    final command = Command.createAsyncNoParam<String>(
-      () async {
-        await Future.delayed(Duration(seconds: 5));
-        return 'delayed result';
-      },
-      initialValue: '',
-    );
-
-    command.listen((value, _) => result = value);
-    command.run();
-
-    // Immediately after run, still initial
-    expect(result, '');
-
-    // Advance time
-    async.elapse(Duration(seconds: 5));
-
-    // Now the result is set
-    expect(result, 'delayed result');
-  });
-});
-```
-
-## Testing Disposal
-
-Verify commands clean up properly:
-
-```dart
-test('Command disposes correctly', () async {
-  var disposed = false;
-
-  final command = Command.createAsyncNoParam<String>(
-    () async => 'result',
-    initialValue: '',
-  );
-
-  // Add listener
-  command.listen((_, __) {});
-
-  // Dispose
-  await command.dispose();
-
-  // Verify disposed (accessing properties should throw)
-  expect(() => command.value, throwsA(anything));
-});
-```
-
-## Integration Testing
-
-### Testing Commands in Managers
-
-```dart
-class DataManager {
-  final api = ApiClient();
-
-  late final loadCommand = Command.createAsyncNoParam<List<String>>(
-    () => api.fetchData(),
-    initialValue: [],
-  );
-
-  void dispose() {
-    loadCommand.dispose();
-  }
-}
-
-test('DataManager integration', () async {
-  final manager = DataManager();
-
-  final result = await manager.loadCommand.runAsync();
-
-  expect(result, isNotEmpty);
-
-  manager.dispose();
-});
-```
-
-### Testing Command Chains
-
-```dart
-test('Commands chain via restrictions', () async {
-  final loadCommand = Command.createAsyncNoParam<void>(
-    () async {
-      await Future.delayed(Duration(milliseconds: 50));
-    },
-  );
-
-  final saveCommand = Command.createAsyncNoParam<void>(
-    () async {},
-    restriction: loadCommand.isRunningSync,
-  );
-
-  loadCommand.run();
-
-  // Save is restricted while load is running
-  expect(saveCommand.canRun.value, false);
-
-  await Future.delayed(Duration(milliseconds: 100));
-
-  // After load completes, save can run
-  expect(saveCommand.canRun.value, true);
-});
-```
-
-## Common Testing Patterns
-
-### Pattern 1: Setup/Teardown
-
-```dart
-group('Command Tests', () {
-  late Command<void, String> command;
-  late Collector<String> collector;
-
-  setUp(() {
-    collector = Collector<String>();
-    command = Command.createAsyncNoParam<String>(
-      () async => 'result',
-      initialValue: '',
-    );
-    command.listen((value, _) => collector(value));
-  });
-
-  tearDown(() async {
-    await command.dispose();
-    collector.reset();
-  });
-
-  test('test 1', () async {
-    // Test using command and collector
-  });
-
-  test('test 2', () async {
-    // Test using command and collector
-  });
-});
-```
-
-### Pattern 2: Verify All States
-
-```dart
-test('Verify complete state flow', () async {
-  final states = <String>[];
-
-  final command = Command.createAsyncNoParam<String>(
-    () async {
-      await Future.delayed(Duration(milliseconds: 50));
-      return 'done';
-    },
-    initialValue: 'initial',
-  );
-
-  command.results.listen((result, _) {
-    if (result.isRunning) {
-      states.add('running');
-    } else if (result.hasError) {
-      states.add('error');
-    } else if (result.hasData) {
-      states.add('success');
-    }
-  });
-
-  await command.runAsync();
-
-  expect(states, ['success', 'running', 'success']);
-  // success (initial), running, success (completed)
-});
-```
-
-### Pattern 3: Error Recovery
-
-```dart
-test('Command recovers after error', () async {
-  var shouldFail = true;
-
-  final command = Command.createAsyncNoParam<String>(
-    () async {
-      if (shouldFail) {
-        throw Exception('Error');
-      }
-      return 'success';
-    },
-    initialValue: '',
-  );
-
-  // First call fails
-  expect(() => command.runAsync(), throwsA(anything));
-
-  await Future.delayed(Duration(milliseconds: 50));
-
-  // Second call succeeds
-  shouldFail = false;
-  final result = await command.runAsync();
-  expect(result, 'success');
-});
-```
-
-## Debugging Tests
-
-### Enable Print Statements
-
-```dart
-void setupCollectors(Command command, {bool enablePrint = true}) {
-  command.canRun.listen((canRun, _) {
-    if (enablePrint) print('canRun: $canRun');
-  });
-
-  command.results.listen((result, _) {
-    if (enablePrint) {
-      print('Result: data=${result.data}, error=${result.error}, '
-          'isRunning=${result.isRunning}');
-    }
-  });
-}
-```
-
-### Use testWidgets for UI Integration
-
-```dart
-testWidgets('CommandBuilder widget test', (tester) async {
-  final command = Command.createAsyncNoParam<String>(
-    () async => 'result',
-    initialValue: '',
-  );
-
-  await tester.pumpWidget(
-    MaterialApp(
-      home: CommandBuilder(
-        command: command,
-        whileRunning: (context, _, __) => CircularProgressIndicator(),
-        onData: (context, data, _) => Text(data),
-      ),
-    ),
-  );
-
-  await tester.pumpAndSettle();
-
-  expect(find.text('result'), findsOneWidget);
-});
-```
-
-## Best Practices
-
-**✅ Do:**
-
-<ul style="list-style: none; padding-left: 0;">
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">✅ Use <code>Collector</code> pattern for state verification</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">✅ Test both success and error paths</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">✅ Verify state transitions with <code>CommandResult</code></li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">✅ Use <code>runAsync()</code> to await results in tests</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">✅ Mock external dependencies</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">✅ Test restriction behavior</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">✅ Verify disposal</li>
-</ul>
-
-**❌️ Don't:**
-
-<ul style="list-style: none; padding-left: 0;">
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">❌️ Access <code>isRunning</code> on sync commands</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">❌️ Forget to dispose commands in tearDown</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">❌️ Test UI and business logic together</li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">❌️ Rely on timing without <code>fake_async</code></li>
-  <li style="padding-left: 1.5em; text-indent: -1.5em;">❌️ Ignore error handling tests</li>
-</ul>
-
 ## See Also
 
 - [Command Basics](/documentation/command_it/command_basics) — Creating commands