feat: add cache token tracking and cache-aware cost calculation

Track cache_read_tokens and cache_write_tokens end-to-end: parse from
provider responses (OpenAI, DeepSeek, Grok, Gemini), persist to SQLite,
apply cache-aware pricing from the model registry, and surface in API
responses and the dashboard.

- Add cache fields to ProviderResponse, StreamUsage, RequestLog structs
- Parse cached_tokens (OpenAI/Grok), prompt_cache_hit/miss (DeepSeek),
  cachedContentTokenCount (Gemini) from provider responses
- Send stream_options.include_usage for streaming; capture real usage
  from final SSE chunk in AggregatingStream
- ALTER TABLE migration for cache_read_tokens/cache_write_tokens columns
- Cache-aware cost formula using registry cache_read/cache_write rates
- Update Provider trait calculate_cost signature across all providers
- Add cache_read_tokens/cache_write_tokens to Usage API response
- Dashboard: cache hit rate card, cache columns in pricing and usage
  tables, cache token aggregation in SQL queries
- Remove API debug panel and verbose console logging from api.js
- Bump static asset cache-bust to v5

src/dashboard/models.rs

@@ -84,6 +84,8 @@ pub(super) async fn handle_get_models(
         let mut enabled = true;
         let mut prompt_cost = m_meta.cost.as_ref().map(|c| c.input).unwrap_or(0.0);
         let mut completion_cost = m_meta.cost.as_ref().map(|c| c.output).unwrap_or(0.0);
+        let cache_read_cost = m_meta.cost.as_ref().and_then(|c| c.cache_read);
+        let cache_write_cost = m_meta.cost.as_ref().and_then(|c| c.cache_write);
         let mut mapping = None::<String>;
 
         if let Some(row) = db_models.get(m_key) {
@@ -105,6 +107,8 @@ pub(super) async fn handle_get_models(
             "enabled": enabled,
             "prompt_cost": prompt_cost,
             "completion_cost": completion_cost,
+            "cache_read_cost": cache_read_cost,
+            "cache_write_cost": cache_write_cost,
             "mapping": mapping,
             "context_limit": m_meta.limit.as_ref().map(|l| l.context).unwrap_or(0),
             "output_limit": m_meta.limit.as_ref().map(|l| l.output).unwrap_or(0),