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/providers/gemini.rs

@@ -119,6 +119,8 @@ struct GeminiUsageMetadata {
     candidates_token_count: u32,
     #[serde(default)]
     total_token_count: u32,
+    #[serde(default)]
+    cached_content_token_count: u32,
 }
 
 #[derive(Debug, Deserialize)]
@@ -454,6 +456,11 @@ impl super::Provider for GeminiProvider {
             .as_ref()
             .map(|u| u.total_token_count)
             .unwrap_or(0);
+        let cache_read_tokens = gemini_response
+            .usage_metadata
+            .as_ref()
+            .map(|u| u.cached_content_token_count)
+            .unwrap_or(0);
 
         Ok(ProviderResponse {
             content,
@@ -462,6 +469,8 @@ impl super::Provider for GeminiProvider {
             prompt_tokens,
             completion_tokens,
             total_tokens,
+            cache_read_tokens,
+            cache_write_tokens: 0, // Gemini doesn't report cache writes separately
             model,
         })
     }
@@ -475,12 +484,16 @@ impl super::Provider for GeminiProvider {
         model: &str,
         prompt_tokens: u32,
         completion_tokens: u32,
+        cache_read_tokens: u32,
+        cache_write_tokens: u32,
         registry: &crate::models::registry::ModelRegistry,
     ) -> f64 {
         super::helpers::calculate_cost_with_registry(
             model,
             prompt_tokens,
             completion_tokens,
+            cache_read_tokens,
+            cache_write_tokens,
             registry,
             &self.pricing,
             0.075,
@@ -537,6 +550,17 @@ impl super::Provider for GeminiProvider {
                         let gemini_response: GeminiResponse = serde_json::from_str(&msg.data)
                             .map_err(|e| AppError::ProviderError(format!("Failed to parse stream chunk: {}", e)))?;
 
+                        // Extract usage from usageMetadata if present (reported on every/last chunk)
+                        let stream_usage = gemini_response.usage_metadata.as_ref().map(|u| {
+                            super::StreamUsage {
+                                prompt_tokens: u.prompt_token_count,
+                                completion_tokens: u.candidates_token_count,
+                                total_tokens: u.total_token_count,
+                                cache_read_tokens: u.cached_content_token_count,
+                                cache_write_tokens: 0,
+                            }
+                        });
+
                         if let Some(candidate) = gemini_response.candidates.first() {
                             let content = candidate
                                 .content
@@ -561,6 +585,7 @@ impl super::Provider for GeminiProvider {
                                 finish_reason,
                                 tool_calls,
                                 model: model.clone(),
+                                usage: stream_usage,
                             };
                         }
                     }