Rename the Fly-mode Warnings tab to System Messages, log connection/upload events

Renames DroneEvent/DroneEventSeverity/droneEventLogProvider/
DroneStatusWarningsPanel to SystemMessage/SystemMessageSeverity/
systemMessageLogProvider/DroneStatusMessagesPanel throughout, matching
what the tab now actually shows - general system messages, not just
drone-health warnings.

Adds a new SystemMessageSeverity.info level (blue) for messages that
aren't a warning/error, and three new message sources on top of the
existing battery/failsafe detection:
- "Connected", logged the first time telemetryProvider produces a frame
  after having none - the mirror image of the existing "Connection lost"
  detection (which already fires on the first stream error after having
  had data), so no new transport-specific dependency was needed.
- "Connection type changed to X", from watching connectionSettingsProvider
  (skips the initial load so it doesn't fire on every app start).
- "Mission sent (N waypoints)" / "Mission upload failed: ...", logged
  from FlyScreen's send handler via a new public log() method on the
  notifier, alongside the existing snackbar.

Verified on the Pixel_10a emulator: entering Fly mode logs "Connected"
once the mock telemetry starts, and tapping the send button logs
"Mission sent (3 waypoints)" right after the snackbar.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

app/test/ui/providers/system_message_log_provider_test.dart

@@ -0,0 +1,142 @@
+import 'dart:async';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import 'package:dmc_app/domain/telemetry/system_message.dart';
+import 'package:dmc_app/transport/connection_type.dart';
+import 'package:dmc_app/transport/flight_controller_link.dart';
+import 'package:dmc_app/ui/providers/connection_settings_provider.dart';
+import 'package:dmc_app/ui/providers/system_message_log_provider.dart';
+import 'package:dmc_app/ui/providers/telemetry_provider.dart';
+
+TelemetryFrame _frame() => const TelemetryFrame(
+      lat: 52.5,
+      lon: 13.4,
+      hasFix: true,
+      numSat: 10,
+      altitudeM: 100,
+      speedMs: 15,
+      headingDeg: 0,
+      armed: false,
+      batteryPercent: 80,
+      batteryVoltage: 22.0,
+      currentA: 10.0,
+      linkQuality: 90,
+      snrDb: 5,
+      hdop: 1.0,
+      navMode: 0,
+      flightMode: 'Idle',
+    );
+
+typedef _ConnectionSettings = ({
+  int? activeDroneProfileId,
+  int? currentMissionId,
+  String? connectionDeviceAddress,
+  bool connectionAutoConnect,
+  ConnectionType connectionType,
+  String? connectionWifiHost,
+  int connectionWifiPort,
+  String connectionWifiSsidPrefix,
+  String? connectionWifiLastSsid,
+});
+
+_ConnectionSettings _settings(ConnectionType type) => (
+      activeDroneProfileId: null,
+      currentMissionId: null,
+      connectionDeviceAddress: null,
+      connectionAutoConnect: true,
+      connectionType: type,
+      connectionWifiHost: null,
+      connectionWifiPort: 14550,
+      connectionWifiSsidPrefix: 'mLRS-',
+      connectionWifiLastSsid: null,
+    );
+
+void main() {
+  test('loggt "Connected" beim ersten Telemetrie-Frame und "Connection '
+      'lost" bei einem anschliessenden Stream-Fehler', () async {
+    final controller = StreamController<TelemetryFrame>();
+    addTearDown(controller.close);
+    final container = ProviderContainer(overrides: [
+      telemetryProvider.overrideWith((ref) => controller.stream),
+      connectionSettingsProvider
+          .overrideWith((ref) async => _settings(ConnectionType.mock)),
+    ]);
+    addTearDown(container.dispose);
+    container.listen(systemMessageLogProvider, (previous, next) {});
+
+    controller.add(_frame());
+    await Future<void>.delayed(Duration.zero);
+
+    final afterConnect = container.read(systemMessageLogProvider);
+    expect(afterConnect, hasLength(1));
+    expect(afterConnect.single.message, 'Connected');
+    expect(afterConnect.single.severity, SystemMessageSeverity.info);
+
+    controller.addError(StateError('link down'));
+    await Future<void>.delayed(Duration.zero);
+
+    final afterLost = container.read(systemMessageLogProvider);
+    expect(afterLost.first.message, 'Connection lost');
+    expect(afterLost.first.severity, SystemMessageSeverity.critical);
+  });
+
+  test('loggt keine "Connected"-Meldung, solange nie ein Frame ankommt', () async {
+    final container = ProviderContainer(overrides: [
+      telemetryProvider.overrideWith((ref) => const Stream<TelemetryFrame>.empty()),
+      connectionSettingsProvider
+          .overrideWith((ref) async => _settings(ConnectionType.mock)),
+    ]);
+    addTearDown(container.dispose);
+
+    container.listen(systemMessageLogProvider, (previous, next) {});
+    await Future<void>.delayed(Duration.zero);
+
+    expect(container.read(systemMessageLogProvider), isEmpty);
+  });
+
+  test('loggt "Connection type changed" bei einer Aenderung, nicht beim '
+      'initialen Laden der Einstellungen', () async {
+    var type = ConnectionType.wifi;
+    final container = ProviderContainer(overrides: [
+      telemetryProvider.overrideWith((ref) => const Stream<TelemetryFrame>.empty()),
+      connectionSettingsProvider.overrideWith((ref) async => _settings(type)),
+    ]);
+    addTearDown(container.dispose);
+
+    container.listen(systemMessageLogProvider, (previous, next) {});
+    await container.read(connectionSettingsProvider.future);
+    expect(container.read(systemMessageLogProvider), isEmpty);
+
+    type = ConnectionType.mock;
+    container.invalidate(connectionSettingsProvider);
+    await container.read(connectionSettingsProvider.future);
+
+    final log = container.read(systemMessageLogProvider);
+    expect(log.single.message, 'Connection type changed to Mock (Test)');
+    expect(log.single.severity, SystemMessageSeverity.info);
+  });
+
+  test('log() fuegt einen Eintrag manuell hinzu (Doku: Wegpunkte uebertragen)', () async {
+    final container = ProviderContainer(overrides: [
+      telemetryProvider.overrideWith((ref) => const Stream<TelemetryFrame>.empty()),
+      connectionSettingsProvider
+          .overrideWith((ref) async => _settings(ConnectionType.mock)),
+    ]);
+    addTearDown(container.dispose);
+
+    container.read(systemMessageLogProvider.notifier).log('Mission sent (3 waypoints)');
+    var log = container.read(systemMessageLogProvider);
+    expect(log.single.message, 'Mission sent (3 waypoints)');
+    expect(log.single.severity, SystemMessageSeverity.info);
+
+    container.read(systemMessageLogProvider.notifier).log(
+          'Mission upload failed: timeout',
+          severity: SystemMessageSeverity.critical,
+        );
+    log = container.read(systemMessageLogProvider);
+    expect(log.first.message, 'Mission upload failed: timeout');
+    expect(log.first.severity, SystemMessageSeverity.critical);
+  });
+}