feat(metadata): 元数据引擎第 2 步——置信度模型 + pending/verified 状态机

之前 evaluate() 写死 0.8、decide() 直接透传，history 参数没人用，
"自学习"只有骨架。这次补上：

置信度（MetadataNormalizer.evaluate）
- 字段来源可追溯：NormalizedMetadata 新增 titleFromTag / artistFromTag / albumFromTag
- 基础分 0.25；标题 +0.20、标题来自标签再 +0.10（文件名当标题则 -0.10）
- 艺术家 +0.15、来自标签 +0.10；专辑 +0.10；年份 +0.03；封面 +0.02
- 历史一致性：同艺人 >=2 条 +0.05，同专辑 >=2 条 +0.03
- 结果 clamp 到 0.05~0.98，且每个加分项写入 evidence，便于日志解释

状态机（MetadataService）
- 只有 confidence>=0.6 且 status=verified 的记录才直接命中
- pending 记录下次播放会重新读取并合并（自修复）
- validation_count 累加；>=2 次且置信度达标才升级为 verified
- 新结果置信度低于旧结果时保留旧字段，只累加验证次数
- 日志输出 status / confidence / validation_count / evidence

测试
- 新增 test/metadata_normalizer_test.dart，9 个用例覆盖来源标记、分级、
  历史加权、证据、阈值；flutter test 全绿

真机验证
- 起播看门狗在真实弱网下触发：23:44:50 打开失败 → 15s 后自动重连 →
  1.4s 出声（open 仅 100ms）

lib/metadata/metadata_service.dart

@@ -70,12 +70,16 @@ class MetadataService {
     final stat = await file.stat();
     final songKey = _generateSongKey(url, stat.size);
 
-    // 3. SQLite 查询（高置信度直接使用）
+    // 3. SQLite 查询：只有「已验证」的记录才直接返回。
+    //    pending 记录会继续往下走，重新读取并累计 validation_count，
+    //    这就是自修复：置信度不足的记录会在下次播放时被重新确认。
+    Map<String, dynamic>? dbSong;
     if (!forceRefresh) {
-      final dbSong = await _db.getSong(songKey);
+      dbSong = await _db.getSong(songKey);
       if (dbSong != null) {
         final confidence = (dbSong['confidence'] as num?)?.toDouble() ?? 0.0;
-        if (confidence >= 0.6) {
+        final status = dbSong['metadata_status'] as String? ?? 'pending';
+        if (confidence >= 0.6 && status == 'verified') {
           debugPrint(
               '📦 [MetadataService] SQLite hit: ${dbSong['title']} - ${dbSong['artist']}');
 
@@ -104,6 +108,8 @@ class MetadataService {
           await _memoryCache.put(fileId, metadata);
           return metadata;
         }
+        debugPrint('🔁 [MetadataService] 记录未验证'
+            '（conf=${confidence.toStringAsFixed(2)}, status=$status），重新确认');
       }
     }
 
@@ -117,47 +123,78 @@ class MetadataService {
       filePath: url,
     );
 
-    // 6. 评估
+    // 6. 评估（含历史一致性）
     final history = await _db.getSongsByArtist(normalized.artist, limit: 10);
     final candidate = _normalizer.evaluate(normalized, history);
     final finalMetadata = _normalizer.decide(candidate);
-    debugPrint(
-        '📢 [MetadataService] finalMetadata.artwork is ${finalMetadata.artwork != null ? 'not null (${finalMetadata.artwork!.length} bytes)' : 'null'}');
 
-    // 7. 保存封面图到本地
-    String? artworkPath;
-    if (finalMetadata.artwork != null && finalMetadata.artwork!.isNotEmpty) {
+    // 7. 与已有记录合并
+    final prevConfidence = (dbSong?['confidence'] as num?)?.toDouble() ?? 0.0;
+    final validationCount = ((dbSong?['validation_count'] as int?) ?? 0) + 1;
+    final useNew = dbSong == null || candidate.confidence >= prevConfidence;
+    final effectiveConfidence =
+        useNew ? candidate.confidence : prevConfidence;
+
+    // 8. 保存封面图（只有采用新结果且确实读到图时才写）
+    String? artworkPath = dbSong?['artwork_path'] as String?;
+    if (useNew &&
+        finalMetadata.artwork != null &&
+        finalMetadata.artwork!.isNotEmpty) {
       artworkPath =
           await ArtworkHelper.saveArtwork(finalMetadata.artwork!, songKey);
     }
 
-    // 8. 保存到 SQLite
-    // 注意：remote_path 必须存「应用内的歌曲路径」（即 fileId / song.id），
-    // 不能存完整 URL。playback_controller 与 AudioService 都是用相对路径
-    // 调 getSongByPath() 的，存 URL 会导致永远查不到、元数据看起来“没吃上”。
-    await _db.insertSong({
+    final status =
+        (effectiveConfidence >= 0.6 && validationCount >= 2) ? 'verified' : 'pending';
+
+    final row = <String, dynamic>{
       'song_key': songKey,
+      // remote_path 必须存应用内路径（fileId / song.id），不能存完整 URL
       'remote_path': fileId,
       'file_size': stat.size,
       'modified_time': stat.modified.millisecondsSinceEpoch,
-      'title': finalMetadata.title,
-      'artist': finalMetadata.artist,
-      'album': finalMetadata.album,
-      'genre': finalMetadata.genre,
+      'title': useNew ? finalMetadata.title : (dbSong?['title'] ?? finalMetadata.title),
+      'artist':
+          useNew ? finalMetadata.artist : (dbSong?['artist'] ?? finalMetadata.artist),
+      'album': useNew ? finalMetadata.album : (dbSong?['album'] ?? finalMetadata.album),
+      'genre': useNew ? finalMetadata.genre : (dbSong?['genre'] ?? finalMetadata.genre),
       'artwork_path': artworkPath,
-      'confidence': candidate.confidence,
-      'validation_count': 1,
-      'first_scan': DateTime.now().millisecondsSinceEpoch,
+      'confidence': effectiveConfidence,
+      'validation_count': validationCount,
+      'first_scan':
+          dbSong?['first_scan'] ?? DateTime.now().millisecondsSinceEpoch,
       'last_scan': DateTime.now().millisecondsSinceEpoch,
-      'metadata_status': candidate.confidence >= 0.6 ? 'verified' : 'pending',
-    });
+      'metadata_status': status,
+    };
+
+    if (dbSong == null) {
+      await _db.insertSong(row);
+    } else {
+      await _db.updateSong(songKey, row);
+    }
+
+    final merged = FinalMetadata(
+      title: row['title'] as String? ?? '',
+      artist: row['artist'] as String? ?? '',
+      album: row['album'] as String? ?? '',
+      genre: row['genre'] as String? ?? '',
+      genres: finalMetadata.genres,
+      performers: finalMetadata.performers,
+      year: finalMetadata.year,
+      duration: finalMetadata.duration,
+      artwork: finalMetadata.artwork,
+      source: status,
+    );
 
     // 9. 内存缓存
-    await _memoryCache.put(fileId, finalMetadata);
+    await _memoryCache.put(fileId, merged);
 
-    debugPrint(
-        '✅ [MetadataService] saved: ${finalMetadata.title} - ${finalMetadata.artist} (confidence: ${candidate.confidence})');
-    return finalMetadata;
+    debugPrint('📊 [MetadataService] $status '
+        'conf=${effectiveConfidence.toStringAsFixed(2)} '
+        'validations=$validationCount '
+        'evidence=${candidate.evidence}');
+    debugPrint('✅ [MetadataService] saved: ${merged.title} - ${merged.artist}');
+    return merged;
   }
 
   FinalMetadata _fallbackFromFileName(String fileName) {