chore: Change several panics to warn messages

A lot of these can fire as the system spins down, and will crash

buttplug/src/server/device/hardware/communication/lovense_connect_service/lovense_connect_service_comm_manager.rs

···
 use crate::{
   core::errors::ButtplugDeviceError,
   server::device::hardware::communication::{
-    HardwareCommunicationManager,
-    HardwareCommunicationManagerBuilder,
-    HardwareCommunicationManagerEvent,
-    TimedRetryCommunicationManager,
+    HardwareCommunicationManager, HardwareCommunicationManagerBuilder,
+    HardwareCommunicationManagerEvent, TimedRetryCommunicationManager,
     TimedRetryCommunicationManagerImpl,
   },
 };
···
         return None;
       }
 
-      let text = res
-        .text()
-        .await
-        .expect("If we got a 200 back, we should at least have text.");
-      let info: LovenseServiceLocalInfo = serde_json::from_str(&text)
-        .expect("Should always get json back from service, if we got a response.");
-      Some(info)
+      match res.text().await {
+        Ok(text) => match serde_json::from_str(&text) {
+          Ok(info) => Some(info),
+          Err(e) => {
+            warn!("Should always get json back from service, if we got a response: ${e}");
+            None
+          }
+        },
+        Err(e) => {
+          warn!("If we got a 200 back, we should at least have text: ${e}");
+          None
+        }
+      }
     }
     Err(err) => {
       error!(

buttplug/src/server/device/hardware/communication/lovense_dongle/lovense_dongle_state_machine.rs

···
   }
 
   pub async fn send_output(&self, msg: OutgoingLovenseData) {
-    self
+    if self
       .dongle_outgoing
       .send(msg)
       .await
-      .expect("Won't get here without owner being alive.");
+      .is_err() {
+        warn!("Dongle message sent without owner being alive, assuming shutdown.");
+      }
   }
 
   pub async fn send_event(&self, msg: HardwareCommunicationManagerEvent) {
···
           self.is_scanning.store(false, Ordering::SeqCst);
           should_scan = false;
           // If we were requested to scan and then asked to stop, act like we at least tried.
-          self
+          if self
             .event_sender
             .send(HardwareCommunicationManagerEvent::ScanningFinished)
             .await
-            .expect("Won't get here without owner being alive.");
+            .is_err() {
+              warn!("Dongle message sent without owner being alive, assuming shutdown.");
+          }
         }
       }
     }
···
                 }
               }
             }
-            _ => device_read_sender
+            _ => {
+              if device_read_sender
               .send(dongle_msg)
               .await
-              .expect("Won't get here if the parent isn't alive."),
+              .is_err() {
+                warn!("Dongle message sent without owner being alive, assuming shutdown.");
+              }
+            }
           }
         }
         IncomingMessage::CommMgr(comm_msg) => match comm_msg {

buttplug/src/server/device/hardware/communication/lovense_dongle/lovense_hid_dongle_comm_manager.rs

···
 
       *(held_read_thread.lock().await) = Some(read_thread);
       *(held_write_thread.lock().await) = Some(write_thread);
-      machine_sender_clone
+      if machine_sender_clone
         .send(LovenseDeviceCommand::DongleFound(
           writer_sender,
           reader_receiver,
         ))
         .await
-        .expect("We've already spun up the state machine so we know this receiver exists.");
+        .is_err() {
+          warn!("We've already spun up the state machine, this receiver should exist, but if we're shutting down this will throw.");
+        }
       info!("Found Lovense HID Dongle");
       Ok(())
     }

buttplug/src/server/device/hardware/communication/serialport/serialport_hardware.rs

···
     let data = msg.data.clone();
     // TODO Should check endpoint validity
     async move {
-      sender
+      if sender
         .send(data)
         .await
-        .expect("Tasks should exist if we get here.");
+        .is_err() {
+          warn!("Tasks should exist if we get here, but may not if we're shutting down");
+        }
       Ok(())
     }
     .boxed()