refactor: 全面重构核心架构，消除反复修改的根因

- 删除 ValidationQueue 双轨持久化队列，替换为纯内存 AsyncWorkerPool
- 引入统一后台任务框架 JobExecutor（Job/CrawlJob/ValidateAllJob）
- 新增 PluginRunner 统一插件执行（超时、重试、健康检查、统计）
- 重构 SchedulerService 职责收敛为仅定时触发 ValidateAllJob
- 使用 AsyncExitStack 重构 lifespan，安全管理长生命周期资源
- 路由层瘦身 50%+，业务异常上抛由全局中间件统一处理
- 实现设置全热更新（WorkerPool 并发、Validator 超时即时生效）
- 前端 Store 强制写后重新拉取，消除乐观更新数据不同步
- 删除 queue.py / task_repo.py / task_service.py
- 新增 execution 单元测试，全部 85 个测试通过

app/repositories/__init__.py

@@ -1,11 +1,9 @@
 """数据访问层包"""
 from .proxy_repo import ProxyRepository
 from .settings_repo import SettingsRepository, PluginSettingsRepository
-from .task_repo import ValidationTaskRepository
 
 __all__ = [
     "ProxyRepository",
     "SettingsRepository",
     "PluginSettingsRepository",
-    "ValidationTaskRepository",
 ]

app/repositories/task_repo.py

@@ -1,130 +0,0 @@
-"""验证任务队列持久化层"""
-import aiosqlite
-from typing import List, Optional
-from app.models.domain import ProxyRaw
-from app.core.log import logger
-
-
-class ValidationTaskRepository:
-    """验证任务 Repository —— 支持队列持久化"""
-
-    @staticmethod
-    async def insert_batch(db: aiosqlite.Connection, proxies: List[ProxyRaw]) -> int:
-        if not proxies:
-            return 0
-        try:
-            rows = [(p.ip, p.port, p.protocol) for p in proxies]
-            await db.executemany(
-                """
-                INSERT INTO validation_tasks (ip, port, protocol, status, created_at)
-                VALUES (?, ?, ?, 'pending', CURRENT_TIMESTAMP)
-                """,
-                rows,
-            )
-            await db.commit()
-            return len(rows)
-        except Exception as e:
-            logger.error(f"insert_batch validation tasks failed: {e}")
-            return 0
-
-    @staticmethod
-    async def acquire_pending(db: aiosqlite.Connection) -> Optional[dict]:
-        """原子性地获取一个 pending 任务并将其标记为 processing"""
-        try:
-            async with db.execute(
-                """
-                UPDATE validation_tasks
-                SET status = 'processing', updated_at = CURRENT_TIMESTAMP
-                WHERE id = (SELECT id FROM validation_tasks WHERE status = 'pending' ORDER BY id ASC LIMIT 1)
-                RETURNING id, ip, port, protocol
-                """
-            ) as cursor:
-                row = await cursor.fetchone()
-                if not row:
-                    return None
-                return {"id": row[0], "ip": row[1], "port": row[2], "protocol": row[3]}
-        except Exception as e:
-            logger.error(f"acquire_pending failed: {e}")
-            return None
-
-    @staticmethod
-    async def complete_task(
-        db: aiosqlite.Connection,
-        task_id: int,
-        is_valid: bool,
-        response_time_ms: Optional[float] = None,
-    ) -> bool:
-        try:
-            await db.execute(
-                """
-                UPDATE validation_tasks
-                SET status = 'completed',
-                    result = ?,
-                    response_time_ms = ?,
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE id = ?
-                """,
-                ("valid" if is_valid else "invalid", response_time_ms, task_id),
-            )
-            await db.commit()
-            return True
-        except Exception as e:
-            logger.error(f"complete_task failed: {e}")
-            return False
-
-    @staticmethod
-    async def fail_task(db: aiosqlite.Connection, task_id: int) -> bool:
-        try:
-            await db.execute(
-                """
-                UPDATE validation_tasks
-                SET status = 'failed',
-                    result = 'invalid',
-                    updated_at = CURRENT_TIMESTAMP
-                WHERE id = ?
-                """,
-                (task_id,),
-            )
-            await db.commit()
-            return True
-        except Exception as e:
-            logger.error(f"fail_task failed: {e}")
-            return False
-
-    @staticmethod
-    async def get_pending_count(db: aiosqlite.Connection) -> int:
-        async with db.execute(
-            "SELECT COUNT(*) FROM validation_tasks WHERE status = 'pending'"
-        ) as cursor:
-            row = await cursor.fetchone()
-            return row[0] if row else 0
-
-    @staticmethod
-    async def reset_processing(db: aiosqlite.Connection) -> int:
-        """将异常中断的 processing 任务重置为 pending，用于启动恢复"""
-        try:
-            await db.execute(
-                """
-                UPDATE validation_tasks
-                SET status = 'pending', updated_at = CURRENT_TIMESTAMP
-                WHERE status = 'processing'
-                """
-            )
-            await db.commit()
-            return db.total_changes
-        except Exception as e:
-            logger.error(f"reset_processing failed: {e}")
-            return 0
-
-    @staticmethod
-    async def cleanup_old(db: aiosqlite.Connection, days: int = 7) -> int:
-        try:
-            await db.execute(
-                "DELETE FROM validation_tasks WHERE updated_at < datetime('now', '-' || ? || ' days')",
-                (days,),
-            )
-            await db.commit()
-            return db.total_changes
-        except Exception as e:
-            logger.error(f"cleanup_old tasks failed: {e}")
-            return 0