fix: remove 12 production unwrap() calls for JSF compliance

JSF AV Rule 208 adaptation: Replace panicking unwrap() with proper
error handling in I/O operations that can legitimately fail.

Changes:
- scheduler.rs: Handle missing core affinity gracefully with fallback
  to non-pinned workers instead of panicking
- net/tcp.rs: Propagate socket timeout errors with ? instead of unwrap()
- net/udp.rs: Propagate socket timeout errors with ? instead of unwrap()
- io/sys/unix/net/*: Update UdpRecvFrom, UdpSendTo, UnixRecvFrom,
  UnixSendTo to return io::Result<Self> and propagate timeout errors
- io/sys/windows/net/*: Same treatment for Windows UDP operations

Production unwrap() count reduced from 52 to 40.
Remaining unwraps are mostly mutex lock operations (idiomatic for
handling poisoned locks) and internal invariant assertions.

All tests pass (297 passed, 3 skipped for known flaky behavior)
All clippy checks pass with strict JSF-aligned lints

Author: casibbald

src/io/sys/unix/net/udp_recv_from.rs

@@ -22,15 +22,15 @@ pub struct UdpRecvFrom<'a> {
 }
 
 impl<'a> UdpRecvFrom<'a> {
-    pub fn new(socket: &'a UdpSocket, buf: &'a mut [u8]) -> Self {
-        UdpRecvFrom {
+    pub fn new(socket: &'a UdpSocket, buf: &'a mut [u8]) -> io::Result<Self> {
+        Ok(UdpRecvFrom {
             io_data: socket.as_io_data(),
             buf,
             socket: socket.inner(),
             #[cfg(feature = "io_timeout")]
-            timeout: socket.read_timeout().unwrap(),
+            timeout: socket.read_timeout()?,
             is_coroutine: is_coroutine(),
-        }
+        })
     }
 
     pub fn done(&mut self) -> io::Result<(usize, SocketAddr)> {

src/io/sys/unix/net/udp_send_to.rs

@@ -28,7 +28,7 @@ impl<'a, A: ToSocketAddrs> UdpSendTo<'a, A> {
             socket: socket.inner(),
             addr,
             #[cfg(feature = "io_timeout")]
-            timeout: socket.write_timeout().unwrap(),
+            timeout: socket.write_timeout()?,
             is_coroutine: is_coroutine(),
         })
     }

src/io/sys/unix/net/unix_recv_from.rs

@@ -22,15 +22,15 @@ pub struct UnixRecvFrom<'a> {
 }
 
 impl<'a> UnixRecvFrom<'a> {
-    pub fn new(socket: &'a UnixDatagram, buf: &'a mut [u8]) -> Self {
-        UnixRecvFrom {
+    pub fn new(socket: &'a UnixDatagram, buf: &'a mut [u8]) -> io::Result<Self> {
+        Ok(UnixRecvFrom {
             io_data: socket.0.as_io_data(),
             buf,
             socket: socket.0.inner(),
             #[cfg(feature = "io_timeout")]
-            timeout: socket.0.read_timeout().unwrap(),
+            timeout: socket.0.read_timeout()?,
             is_coroutine: is_coroutine(),
-        }
+        })
     }
 
     pub fn done(&mut self) -> io::Result<(usize, SocketAddr)> {

src/io/sys/unix/net/unix_send_to.rs

@@ -28,7 +28,7 @@ impl<'a> UnixSendTo<'a> {
             socket: socket.0.inner(),
             path,
             #[cfg(feature = "io_timeout")]
-            timeout: socket.write_timeout().unwrap(),
+            timeout: socket.write_timeout()?,
             is_coroutine: is_coroutine(),
         })
     }

src/io/sys/windows/net/udp_recv_from.rs

@@ -28,17 +28,17 @@ pub struct UdpRecvFrom<'a> {
 }
 
 impl<'a> UdpRecvFrom<'a> {
-    pub fn new(socket: &'a UdpSocket, buf: &'a mut [u8]) -> Self {
-        UdpRecvFrom {
+    pub fn new(socket: &'a UdpSocket, buf: &'a mut [u8]) -> io::Result<Self> {
+        Ok(UdpRecvFrom {
             io_data: EventData::new(socket.as_raw_socket() as HANDLE),
             buf,
             socket: socket.inner(),
             addr: SocketAddrBuf::new(),
             #[cfg(feature = "io_timeout")]
-            timeout: socket.read_timeout().unwrap(),
+            timeout: socket.read_timeout()?,
             can_drop: DelayDrop::new(),
             is_coroutine: is_coroutine(),
-        }
+        })
     }
 
     pub fn done(&mut self) -> io::Result<(usize, SocketAddr)> {

src/io/sys/windows/net/udp_send_to.rs

@@ -27,18 +27,23 @@ impl<'a> UdpSendTo<'a> {
         buf: &'a [u8],
         addr: A,
     ) -> io::Result<Self> {
-        addr.to_socket_addrs()?
+        let resolved_addr = addr
+            .to_socket_addrs()?
             .next()
-            .ok_or_else(|| io::Error::other("no socket addresses resolved"))
-            .map(|addr| UdpSendTo {
-                io_data: EventData::new(socket.as_raw_socket() as HANDLE),
-                buf,
-                socket: socket.inner(),
-                addr,
-                #[cfg(feature = "io_timeout")]
-                timeout: socket.write_timeout().unwrap(),
-                is_coroutine: is_coroutine(),
-            })
+            .ok_or_else(|| io::Error::other("no socket addresses resolved"))?;
+        
+        #[cfg(feature = "io_timeout")]
+        let timeout = socket.write_timeout()?;
+        
+        Ok(UdpSendTo {
+            io_data: EventData::new(socket.as_raw_socket() as HANDLE),
+            buf,
+            socket: socket.inner(),
+            addr: resolved_addr,
+            #[cfg(feature = "io_timeout")]
+            timeout,
+            is_coroutine: is_coroutine(),
+        })
     }
 
     pub fn done(&mut self) -> io::Result<usize> {

src/net/tcp.rs

@@ -100,9 +100,9 @@ impl TcpStream {
     pub fn try_clone(&self) -> io::Result<TcpStream> {
         let s = self.sys.try_clone().and_then(TcpStream::new)?;
         #[cfg(feature = "io_timeout")]
-        s.set_read_timeout(self.read_timeout.get()).unwrap();
+        s.set_read_timeout(self.read_timeout.get())?;
         #[cfg(feature = "io_timeout")]
-        s.set_write_timeout(self.write_timeout.get()).unwrap();
+        s.set_write_timeout(self.write_timeout.get())?;
         Ok(s)
     }
 
@@ -367,7 +367,9 @@ impl TcpListener {
     pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<TcpListener> {
         use socket2::{Domain, Socket, Type};
         let mut addrs = addr.to_socket_addrs()?;
-        let addr = addrs.next().unwrap();
+        let addr = addrs.next().ok_or_else(|| {
+            io::Error::new(io::ErrorKind::InvalidInput, "no addresses resolved")
+        })?;
         let listener = match &addr {
             SocketAddr::V4(_) => Socket::new(Domain::IPV4, Type::STREAM, None)?,
             SocketAddr::V6(_) => Socket::new(Domain::IPV6, Type::STREAM, None)?,

src/net/udp.rs

@@ -58,9 +58,9 @@ impl UdpSocket {
     pub fn try_clone(&self) -> io::Result<UdpSocket> {
         let s = self.sys.try_clone().and_then(UdpSocket::new)?;
         #[cfg(feature = "io_timeout")]
-        s.set_read_timeout(self.read_timeout.get()).unwrap();
+        s.set_read_timeout(self.read_timeout.get())?;
         #[cfg(feature = "io_timeout")]
-        s.set_write_timeout(self.write_timeout.get()).unwrap();
+        s.set_write_timeout(self.write_timeout.get())?;
         Ok(s)
     }
 
@@ -123,7 +123,7 @@ impl UdpSocket {
             }
         }
 
-        let mut reader = net_impl::UdpRecvFrom::new(self, buf);
+        let mut reader = net_impl::UdpRecvFrom::new(self, buf)?;
         yield_with_io(&reader, reader.is_coroutine);
         reader.done()
     }

src/os/unix/net.rs

@@ -819,7 +819,7 @@ impl UnixDatagram {
             }
         }
 
-        let mut reader = net_impl::UnixRecvFrom::new(self, buf);
+        let mut reader = net_impl::UnixRecvFrom::new(self, buf)?;
         yield_with_io(&reader, reader.is_coroutine);
         reader.done()
     }

src/scheduler.rs

@@ -60,17 +60,32 @@ fn init_scheduler() {
         s.timer_thread.run(&timer_event_handler);
     });
 
-    let core_ids = core_affinity::get_core_ids().unwrap();
-    let pin_cores = config().get_worker_pin();
+    let core_ids = core_affinity::get_core_ids();
+    let pin_cores = config().get_worker_pin() && core_ids.is_some();
+    
+    if pin_cores && core_ids.is_none() {
+        eprintln!("[may] Warning: Core affinity not available on this system, worker pinning disabled");
+    }
+    
     // io event loop thread
-    for (id, core) in (0..workers).zip(core_ids.into_iter().cycle()) {
-        thread::spawn(move || {
-            if pin_cores {
-                core_affinity::set_for_current(core);
-            }
-            let s = unsafe { &*SCHED };
-            s.event_loop.run(id);
-        });
+    if let Some(cores) = core_ids {
+        for (id, core) in (0..workers).zip(cores.into_iter().cycle()) {
+            thread::spawn(move || {
+                if pin_cores {
+                    core_affinity::set_for_current(core);
+                }
+                let s = unsafe { &*SCHED };
+                s.event_loop.run(id);
+            });
+        }
+    } else {
+        // Fallback: spawn workers without core pinning
+        for id in 0..workers {
+            thread::spawn(move || {
+                let s = unsafe { &*SCHED };
+                s.event_loop.run(id);
+            });
+        }
     }
 }