feat: deterministic email-driven status suggestions

New EmailStatusClassifier scans a message subject/body for outcome
signals (interview invite, offer, rejection) and suggests a canonical
pipeline status. Priority-ordered so a rejection that mentions the prior
interview still classifies as Rejected. Deterministic - no AI - so it is
instant, reproducible, and safe.

- GET /api/jobapplications/{id}/status-suggestion reads the job's latest
  inbound correspondence (incl. Gmail imports) and suggests a forward
  status move, suppressed when already in/past that stage
- always human-confirmed via the existing PATCH .../status
- 7 classifier unit tests + 2 endpoint integration tests; backend green (133)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

JobTrackerApi/Controllers/JobApplicationsController.cs

@@ -1604,6 +1604,57 @@ Canonical profile:
             return NoContent();
         }
 
+        public sealed record StatusSuggestionDto(
+            bool HasSuggestion,
+            string? SuggestedStatus,
+            string? CurrentStatus,
+            string? Signal,
+            string? Confidence,
+            DateTime? MessageDate,
+            string? MessageSubject);
+
+        /// <summary>
+        /// Suggests a pipeline status from the job's most recent inbound message (e.g. an interview
+        /// invite or rejection). Deterministic and always human-confirmed via PATCH .../status.
+        /// </summary>
+        [HttpGet("{id:int}/status-suggestion")]
+        public async Task<ActionResult<StatusSuggestionDto>> GetStatusSuggestion([FromRoute] int id, CancellationToken cancellationToken)
+        {
+            var job = await _db.JobApplications.FirstOrDefaultAsync(j => j.Id == id, cancellationToken);
+            if (job is null) return NotFound();
+
+            var none = new StatusSuggestionDto(false, null, job.Status, null, null, null, null);
+
+            var latestInbound = await _db.Correspondences
+                .AsNoTracking()
+                .Where(c => c.JobApplicationId == id
+                    && c.Direction != "outbound"
+                    && c.From != "Me")
+                .OrderByDescending(c => c.Date)
+                .FirstOrDefaultAsync(cancellationToken);
+            if (latestInbound is null) return Ok(none);
+
+            var suggestion = EmailStatusClassifier.Classify(latestInbound.Subject, latestInbound.Content);
+            if (suggestion is null) return Ok(none);
+
+            // Don't nag when the job is already in (or past) the suggested stage.
+            var currentOrder = JobPipeline.OrderOf(job.Status);
+            var suggestedOrder = JobPipeline.OrderOf(suggestion.SuggestedStatus);
+            if (JobPipeline.Normalize(job.Status) == suggestion.SuggestedStatus || currentOrder >= suggestedOrder)
+            {
+                return Ok(none);
+            }
+
+            return Ok(new StatusSuggestionDto(
+                HasSuggestion: true,
+                SuggestedStatus: suggestion.SuggestedStatus,
+                CurrentStatus: job.Status,
+                Signal: suggestion.Signal,
+                Confidence: suggestion.Confidence,
+                MessageDate: latestInbound.Date,
+                MessageSubject: latestInbound.Subject));
+        }
+
 
         [HttpPost("{id:int}/refresh-ai")]
         public async Task<ActionResult<JobApplicationDto>> RefreshAi([FromRoute] int id, CancellationToken cancellationToken)