Prevent non-clone types from entering cloneable layer (#2834)

## Motivation and Context
There is a bug in cloneable layer that allows non-clone types to enter

## Description
Remove `DerefMut` and resolve the consequences

## Testing
- new doc test
- existing orchestrator CI

## Checklist
<!--- If a checkbox below is not applicable, then please DELETE it
rather than leaving it unchecked -->
- [ ] I have updated `CHANGELOG.next.toml` if I made changes to the
smithy-rs codegen or runtime crates
- [ ] I have updated `CHANGELOG.next.toml` if I made changes to the AWS
SDK, generated SDK code, or SDK runtime crates

----

_By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice._

---------

Co-authored-by: John DiSanti <jdisanti@amazon.com>

rust-runtime/aws-smithy-types/src/config_bag.rs

@@ -19,7 +19,7 @@ use std::borrow::Cow;
 use std::fmt::{Debug, Formatter};
 use std::iter::Rev;
 use std::marker::PhantomData;
-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;
 use std::slice::Iter;
 use std::sync::Arc;
 
@@ -64,6 +64,21 @@ impl<T: Default> Default for Value<T> {
 ///
 /// While [`FrozenLayer`] is also cloneable, which is a shallow clone via `Arc`, `CloneableLayer`
 /// performs a deep clone that newly allocates all the items stored in it.
+///
+/// Cloneable enforces that non clone items cannot be added
+/// ```rust,compile_fail
+/// use aws_smithy_types::config_bag::Storable;
+/// use aws_smithy_types::config_bag::StoreReplace;
+/// use aws_smithy_types::config_bag::CloneableLayer;
+/// #[derive(Debug)]
+/// struct MyNotCloneStruct;
+///
+/// impl Storable for MyNotCloneStruct {
+/// type Storer = StoreReplace<MyNotCloneStruct>;
+/// }
+/// let mut layer = CloneableLayer::new("layer");
+/// layer.store_put(MyNotCloneStruct);
+/// ```
 #[derive(Debug, Default)]
 pub struct CloneableLayer(Layer);
 
@@ -75,12 +90,6 @@ impl Deref for CloneableLayer {
  }
 }
 
-impl DerefMut for CloneableLayer {
- fn deref_mut(&mut self) -> &mut Self::Target {
- &mut self.0
- }
-}
-
 impl Clone for CloneableLayer {
  fn clone(&self) -> Self {
  Self(
@@ -110,15 +119,16 @@ impl CloneableLayer {
 
  /// Removes `T` from this bag
  pub fn unset<T: Send + Sync + Clone + Debug + 'static>(&mut self) -> &mut Self {
- self.put_directly::<StoreReplace<T>>(Value::ExplicitlyUnset(type_name::<T>()));
+ self.0.unset::<T>();
  self
  }
 
- fn put_directly<T: Store>(&mut self, value: T::StoredType) -> &mut Self
+ fn put_directly_cloneable<T: Store>(&mut self, value: T::StoredType) -> &mut Self
  where
  T::StoredType: Clone,
  {
- self.props
+ self.0
+ .props
  .insert(TypeId::of::<T>(), TypeErasedBox::new_with_clone(value));
  self
  }
@@ -128,7 +138,7 @@ impl CloneableLayer {
  where
  T: Storable<Storer = StoreReplace<T>> + Clone,
  {
- self.put_directly::<StoreReplace<T>>(Value::Set(item));
+ self.put_directly_cloneable::<StoreReplace<T>>(Value::Set(item));
  self
  }
 
@@ -142,7 +152,7 @@ impl CloneableLayer {
  Some(item) => Value::Set(item),
  None => Value::ExplicitlyUnset(type_name::<T>()),
  };
- self.put_directly::<StoreReplace<T>>(item);
+ self.put_directly_cloneable::<StoreReplace<T>>(item);
  self
  }
 
@@ -164,14 +174,15 @@ impl CloneableLayer {
  where
  T: Storable<Storer = StoreAppend<T>> + Clone,
  {
- self.put_directly::<StoreAppend<T>>(Value::ExplicitlyUnset(type_name::<T>()));
+ self.put_directly_cloneable::<StoreAppend<T>>(Value::ExplicitlyUnset(type_name::<T>()));
  }
 
  fn get_mut_or_default<T: Send + Sync + Store + 'static>(&mut self) -> &mut T::StoredType
  where
  T::StoredType: Default + Clone,
  {
- self.props
+ self.0
+ .props
  .entry(TypeId::of::<T>())
  .or_insert_with(|| TypeErasedBox::new_with_clone(T::StoredType::default()))
  .downcast_mut()