Don't surface task cancellation as a transcription failure (#242)

When the pipeline's parent task is cancelled mid-transcription (a new
recording is started, the engine is torn down, the user toggles again, or
the 120s timeout task group cancels its sibling), the in-flight transcribe
throws a raw Swift.CancellationError. The generic catch treated it as a
real error and wrote a record reading:

  Transcription Failed: The operation couldn't be completed.
  (Swift.CancellationError error 1.)

Cancellation is normal control flow, not a failure. Catch CancellationError
(and the already-cancelled task case) explicitly: discard the empty pending
record, release resources, and return quietly instead of persisting a scary
failed entry. Also re-throw cancellation from the inner AI-enhancement catch
so it is handled the same way rather than relabelled 'Enhancement failed'.

Co-authored-by: thefourCraft <thefourCraft@users.noreply.github.com>

Author: thefourcraft

Zerm/Transcription/Engine/TranscriptionPipeline.swift

@@ -158,6 +158,9 @@ class TranscriptionPipeline {
                     transcription.aiRequestUserMessage = enhancementService.lastUserMessageSent
                     finalPastedText = enhancedText
                 } catch {
+                    // A cancelled enhancement is not a failure — let it propagate to
+                    // the outer cancellation handler instead of relabelling it.
+                    if error is CancellationError { throw error }
                     let errorDescription = (error as? LocalizedError)?.errorDescription ?? error.localizedDescription
                     transcription.enhancedText = "Enhancement failed: \(errorDescription)"
                     let shortReason = String(errorDescription.prefix(80))
@@ -173,7 +176,28 @@ class TranscriptionPipeline {
 
             transcription.transcriptionStatus = TranscriptionStatus.completed.rawValue
 
+        } catch is CancellationError {
+            // The pipeline task was cancelled — e.g. a new recording started, the
+            // engine was torn down, or the user toggled again mid-transcription.
+            // This is normal control flow, NOT a failure: a raw CancellationError
+            // surfaces as the confusing "The operation couldn't be completed.
+            // (Swift.CancellationError error 1.)".  Discard the empty pending record
+            // and bail out quietly instead of writing a "Transcription Failed" entry.
+            logger.notice("⏹️ Transcription cancelled — discarding pending record")
+            modelContext.delete(transcription)
+            try? modelContext.save()
+            await onCleanup()
+            return
         } catch {
+            // A late/transitive cancellation can arrive wrapped or after the task is
+            // already cancelled; treat that as a cancel too rather than a hard failure.
+            if Task.isCancelled {
+                logger.notice("⏹️ Transcription cancelled (task) — discarding pending record")
+                modelContext.delete(transcription)
+                try? modelContext.save()
+                await onCleanup()
+                return
+            }
             let errorDescription = (error as? LocalizedError)?.errorDescription ?? error.localizedDescription
             let recoverySuggestion = (error as? LocalizedError)?.recoverySuggestion ?? ""
             let fullErrorText = recoverySuggestion.isEmpty ? errorDescription : "\(errorDescription) \(recoverySuggestion)"