remove inline and rely on compiler heuristic to do cross-crate inlining

src/lib.rs

···
     }
 
     /// this function never blocks. (`fetch_update` loop doesn't count)
-    #[inline]
     pub fn lock(&mut self) -> ReadGuard<'_, T> {
         let shared_ref = self.shared_ref();
 
···
 unsafe impl<T: Send> Send for Reader<T> {}
 
 impl<T> Drop for Reader<T> {
-    #[inline]
     fn drop(&mut self) {
         // SAFETY: self.shared is valid and not used after this.
         unsafe { Shared::drop(self.shared) };
···
 impl<T> Deref for ReadGuard<'_, T> {
     type Target = T;
 
-    #[inline]
     fn deref(&self) -> &Self::Target {
         // SAFETY: ReadGuard was created, so the Writer knows not to write in this spot
         unsafe { self.shared.get_value_ref(self.value) }
···
     E: ?Sized,
     T: AsRef<E>,
 {
-    #[inline]
     fn as_ref(&self) -> &E {
         self.deref().as_ref()
     }
···
 // unsafe impl<T: Sync> Sync for ReadGuard<'_, T> {}
 
 impl<T> Drop for ReadGuard<'_, T> {
-    #[inline]
     fn drop(&mut self) {
         // release the read lock
         self.shared.release_read_lock();
···
     }
 
     /// get a Reader if none exists
-    #[inline]
     pub fn build_reader(&mut self) -> Option<Reader<T>> {
         let shared_ref = self.shared_ref();
         // SAFETY: all is_unique_with_increase requirements are satisfied.
···
 impl<T: Clone, O> Writer<T, O> {
     /// Creates a new Writer by cloning the value once to get two values
     /// `T::clone()` shoulnd't give a different value, as that would make this library pretty useless
-    #[inline]
     pub fn new(value: T) -> Self {
         let (shared, write_ptr) = Shared::new(value, |value_1| value_1.clone());
         Self {
···
     /// Creates a new Writer by calling `T::default()` twice to create the two values
     ///
     /// Default impl of T needs to give the same result every time. Not upholding this doens't lead to UB, but turns the library basically useless
-    #[inline]
     fn default() -> Self {
         let (shared, write_ptr) = Shared::new(T::default(), |_| T::default());
         Self {
···
 unsafe impl<T: Sync, O> Sync for Writer<T, O> {}
 
 impl<T, O> Drop for Writer<T, O> {
-    #[inline]
     fn drop(&mut self) {
         // SAFETY: self.shared is valid and not used after this.
         unsafe { Shared::drop(self.shared) };
···
 
 impl<T, O> WriteGuard<'_, T, O> {
     /// Makes the changes available to the reader. Equivalent to `std::mem::drop(self)`
-    #[inline]
     pub fn swap(self) {}
 
     /// Gets the value currently being written to.
-    #[inline]
     pub fn read(&self) -> &T {
         // SAFETY: Only the WriteGuard can write to the values / create mut refs to them.
         // The WriteGuard holds a mut ref to the writer so this function can't be called while a writeguard exists
···
 impl<T: Absorb<O>, O: Clone> WriteGuard<'_, T, O> {
     /// applies operation to the current write Value and stores it to apply to the other later.
     /// If there is no reader the operation is applied to both values immediately and not stored.
-    #[inline]
     pub fn apply_op(&mut self, operation: O) {
         if let Some(shared) = self.writer.shared_mut() {
             shared.value_1.get_mut().absorb(operation.clone());
···
 // unsafe impl<T: Sync, O> Sync for WriteGuard<'_, T, O> {}
 
 impl<T, O> Drop for WriteGuard<'_, T, O> {
-    #[inline]
     fn drop(&mut self) {
         self.writer.swap();
     }