impl _queue module + Update multiprocessing to 3.14.5 - #7994

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@crates/stdlib/src/_queue.rs`:
- Around line 152-169: The busy-wait in the queue consumer loop (the block in
the method that calls empty(), get_inner(), and checks start_time/end_time)
should be replaced with a proper blocking wait using a Condvar: protect the
queue state with a Mutex (or use parking_lot::Mutex) and a Condvar (or
parking_lot::Condvar), change the consumer path to call condvar.wait() /
condvar.wait_timeout_until() in a loop that re-checks !self.empty() and the
deadline (using start_time/end_time) before returning unsafe { self.get_inner()
} or Err(empty_error(vm)); update the producer path (e.g., put/insert path) to
notify_one()/notify_all() on the same Condvar after pushing an item so waiters
wake; ensure the timeout branch uses the condvar timeout API instead of busy
polling so the thread sleeps until signaled or deadline expires.
- Around line 164-168: The timeout check in the queue get logic is inverted: in
the block that matches (Some(start), Some(end)) (inside the get method / loop),
change the condition from start.elapsed() < end to start.elapsed() >= end so the
code only returns Err(empty_error(vm)) after the timeout has elapsed (i.e., when
elapsed >= end) instead of immediately; update the conditional covering
(Some(start), Some(end)) accordingly so waiting continues while elapsed < end
and only raises Empty once elapsed >= end.
- Around line 50-70: The current get/get_inner pattern has a race: get calls
self.empty() under a read lock then get_inner takes a separate write lock and
does unsafe pop_front(). Change get_inner (and its callers) to acquire the write
lock once, perform an atomic check-and-pop, and return Option<PyObjectRef>
(removing unsafe and unwrap_unchecked); update get to handle the Option result
instead of relying on a prior empty() check; also fix the doc comment wording
from "Called must ensure" to "Caller must ensure" and remove the unsafe block
and its SAFETY claim.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Outside diff comments:
In `@crates/stdlib/src/_queue.rs`:
- Around line 137-144: SimpleQueue.get() currently uses
Duration::from_secs_f64(v) which can panic for non-finite or out-of-range
inputs; change this to use Duration::try_from_secs_f64(v) and map a failure to
returning an OverflowError via the VM (e.g. vm.new_overflow_error) so the error
is raised to Python instead of crashing the VM; adjust the match branch that
handles Some(v) to call try_from_secs_f64, return Ok(Some(duration)) on success
or return Err(vm.new_overflow_error("timeout out of range")) on failure, keeping
the existing None and negative-value checks intact and referencing
TimeoutSeconds and SimpleQueue.get for locating the change.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Outside diff comments:
In `@crates/stdlib/src/_queue.rs`:
- Around line 213-222: The Comparable impl for PySimpleQueue calls
identical_optimization(...).unwrap(), which panics for ordering ops when it
returns None; change cmp in the impl for PySimpleQueue to call
op.identical_optimization(zelf, other) and if it returns Some(value) return
Ok(value.into()), otherwise return Ok(PyComparisonValue::NotImplemented) (i.e.,
do not unwrap but map the None case to PyComparisonValue::NotImplemented) so
ordering comparisons return NotImplemented instead of panicking.