feat(i18n): Complete internationalization with timezone fixes and language switching

Completes full internationalization coverage for the webmail application with enhanced language support:

- Replace all remaining hardcoded English strings with translation keys
- Add timezone auto-detection to prevent hydration mismatches
- Enable instant client-side language switching without page reload
- Add 60+ new translation keys in English and French locales
- Improve language switcher component with proper state management
- Add health check endpoint for container orchestration

All user-facing text now supports English and French with no hardcoded fallbacks, providing a fully localized experience.

app/api/health/route.ts

@@ -0,0 +1,126 @@
+import { NextResponse } from 'next/server';
+import { NextRequest } from 'next/server';
+
+// Health check thresholds
+const MEMORY_WARNING_THRESHOLD = 0.85; // 85% heap usage
+const MEMORY_CRITICAL_THRESHOLD = 0.95; // 95% heap usage
+
+interface HealthStatus {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  timestamp: string;
+  uptime?: number;
+  version?: string;
+  memory?: {
+    heapUsed: number;
+    heapTotal: number;
+    rss: number;
+    external: number;
+    heapUsagePercent: number;
+  };
+  environment?: string;
+  nodeVersion?: string;
+  warnings?: string[];
+  reason?: string;
+}
+
+/**
+ * Health check endpoint for container orchestration
+ *
+ * GET /api/health - Basic health check (returns 200 OK or 503 Service Unavailable)
+ * GET /api/health?detailed=true - Detailed diagnostics with memory stats
+ * HEAD /api/health - Lightweight health check (status code only)
+ *
+ * Health status based on Node.js heap usage:
+ * - Healthy (200): < 85% heap usage
+ * - Degraded (200): 85-95% heap usage (warnings in detailed mode)
+ * - Unhealthy (503): > 95% heap usage
+ */
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const detailed = searchParams.get('detailed') === 'true';
+
+  try {
+    const timestamp = new Date().toISOString();
+    const memUsage = process.memoryUsage();
+    const heapUsagePercent = (memUsage.heapUsed / memUsage.heapTotal) * 100;
+
+    // Determine health status based on memory usage
+    let status: 'healthy' | 'degraded' | 'unhealthy' = 'healthy';
+    const warnings: string[] = [];
+    let httpStatus = 200;
+
+    if (heapUsagePercent >= MEMORY_CRITICAL_THRESHOLD * 100) {
+      status = 'unhealthy';
+      httpStatus = 503;
+    } else if (heapUsagePercent >= MEMORY_WARNING_THRESHOLD * 100) {
+      status = 'degraded';
+      warnings.push(`Memory usage high: ${heapUsagePercent.toFixed(1)}%`);
+    }
+
+    // Build response
+    const response: HealthStatus = {
+      status,
+      timestamp,
+    };
+
+    if (status === 'unhealthy') {
+      response.reason = `Memory usage critical: ${heapUsagePercent.toFixed(1)}%`;
+    }
+
+    // Add detailed information if requested
+    if (detailed) {
+      response.uptime = process.uptime();
+      response.version = process.env.npm_package_version || '0.1.0';
+      response.memory = {
+        heapUsed: memUsage.heapUsed,
+        heapTotal: memUsage.heapTotal,
+        rss: memUsage.rss,
+        external: memUsage.external,
+        heapUsagePercent: Number(heapUsagePercent.toFixed(2)),
+      };
+      response.environment = process.env.NODE_ENV || 'development';
+      response.nodeVersion = process.version;
+
+      if (warnings.length > 0) {
+        response.warnings = warnings;
+      }
+    }
+
+    return NextResponse.json(response, {
+      status: httpStatus,
+      headers: {
+        'Cache-Control': 'no-store, no-cache, must-revalidate',
+        'Pragma': 'no-cache',
+        'Expires': '0',
+      },
+    });
+
+  } catch (error) {
+    return NextResponse.json(
+      {
+        status: 'unhealthy',
+        timestamp: new Date().toISOString(),
+        reason: error instanceof Error ? error.message : 'Unknown error',
+      },
+      { status: 503 }
+    );
+  }
+}
+
+/**
+ * HEAD method for ultra-lightweight health checks
+ */
+export async function HEAD() {
+  try {
+    const memUsage = process.memoryUsage();
+    const heapUsagePercent = (memUsage.heapUsed / memUsage.heapTotal) * 100;
+
+    if (heapUsagePercent >= MEMORY_CRITICAL_THRESHOLD * 100) {
+      return new Response(null, { status: 503 });
+    }
+
+    return new Response(null, { status: 200 });
+  } catch {
+    return new Response(null, { status: 503 });
+  }
+}