parallel: fix Ctrl-C hang once the worker pool is running

A terminal Ctrl-C sends SIGINT to the whole foreground process group, so
each ProcessPoolExecutor worker gets it too.  A KeyboardInterrupt raised
inside a worker's compiled demod (or while it holds a multiprocessing
queue lock) wedged the worker in futex_wait; the parent, after writing
the .tbc.db cleanly, then hung in do_wait joining that worker at exit.

Two changes:
- _demod_worker_init sets SIGINT to SIG_IGN, so only the main process
  handles the interrupt and workers never die mid-task holding a lock.
- DemodBlockCache.close() terminate()s the pool's worker processes before
  shutdown(wait=False), so the interpreter's atexit join doesn't block on
  a worker still in a long demod.  Their results are no longer needed.

Reproduced with `ld-decode testdata/ntsc/ve-monitor.ldf mon -t 8` plus a
group SIGINT ~15-24s in: before, the parent hung indefinitely (do_wait on
futex-stuck workers); after, it exits ~0.5s post-INT at every interrupt
point tried (11/13/15/18/20/24s) with an integrity-ok .tbc.db.  A normal
uninterrupted -t8 decode still completes and exits 0.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: happycube

lddecode/parallel.py

@@ -30,6 +30,7 @@
 
 import copy
 import multiprocessing
+import signal
 import threading
 from concurrent.futures import Future, ProcessPoolExecutor, ThreadPoolExecutor
 
@@ -47,6 +48,14 @@ def _demod_worker_init(rf_opts, decoder_params, field_cfg=None):
     import os
     import time as _time
 
+    # A terminal Ctrl-C delivers SIGINT to the whole foreground process
+    # group, workers included.  A KeyboardInterrupt raised inside a
+    # worker's compiled demod - or while it holds a multiprocessing queue
+    # lock - wedges the worker (futex_wait) and the parent then hangs
+    # joining it at exit.  Ignore SIGINT here so only the main process
+    # handles the interrupt; it tears the pool down (see DemodBlockCache).
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+
     from . import utils_logging as logs
     from .rfdecode import RFDecode
 
@@ -570,6 +579,15 @@ def close(self):
         self.flush()
         self._pool.shutdown(wait=False, cancel_futures=True)
         if self._procs is not None:
+            # shutdown(wait=False) leaves the interpreter's atexit handler
+            # to join the workers (wait=True); one still in a long compiled
+            # demod would block that join.  Their results are no longer
+            # needed, so terminate them outright for a prompt exit.
+            for p in list(getattr(self._procs, "_processes", {}).values()):
+                try:
+                    p.terminate()
+                except Exception:
+                    pass
             self._procs.shutdown(wait=False, cancel_futures=True)
             self._procs = None