Fix ddts numeric truncation and the decrypt pool's poison asymmetry

ddts CoreSize wrapped to zero on a maximum-size core. core_size is FSIZE + 1 and
FSIZE is itself 14 bits, so the maximum is 16384 — one past what the 14-bit
CoreSize field holds — and push()'s mask turned that into 0, declaring an empty
core frame. Clamped to 16383 instead: one byte short beats telling a decoder
there is no core. Proven red first (the field read back as 0).

ddts avg/max bitrate under-declared every non-integral frame rate. It computed
sample_rate / frame_samples first, so a 512-sample core at 48 kHz truncated
93.75 frames/s to 93. Multiplying before dividing, with round-to-nearest, keeps
the precision.

set_decrypt_threads skipped the pool swap on a poisoned lock while
DECRYPT_THREADS had already been updated, so the new thread count was reported
as taking effect while the stale pool kept serving. decrypt_pool() deliberately
recovers from poisoning for exactly this reason; the setter now does the same.
The pool Arc is immutable once stored, so a prior panic cannot have left it
half-written.

The CoreSize test decodes the value back out of the emitted box rather than
restating the clamp — a first draft asserted the clamp arithmetic against
itself, which would have passed against the unfixed writer.

src/decrypt.rs

@@ -74,9 +74,14 @@ pub fn set_decrypt_threads(n: usize) {
     DECRYPT_THREADS.store(clamped, Ordering::Relaxed);
     // Drop the existing pool. Next decrypt_pool() call rebuilds with
     // the new resolved thread count.
-    if let Ok(mut guard) = DECRYPT_POOL.write() {
-        *guard = None;
-    }
+    //
+    // Recover the guard on poisoning, exactly as `decrypt_pool` does. Skipping
+    // the swap on a poisoned lock silently kept the STALE pool alive while the
+    // atomic above already reported the new thread count, so the setting appeared
+    // to take effect and never did. The pool Arc is immutable once stored, so a
+    // prior panic cannot have left it half-written.
+    let mut guard = DECRYPT_POOL.write().unwrap_or_else(|e| e.into_inner());
+    *guard = None;
 }
 
 /// Get (or lazily build) the active rayon thread pool. Returns an