core: use specialization for more methods of impl Iterator for &mut I

...and get rid of `ByRefSized`. Most of the iterator methods can be forwarded to the inner iterator if we know that it is `Sized`, but this is currently only done for `fold` and `try_fold`. This PR adds the optimization for all applicable methods. It uses two private helper struct to hide the specialization from the public API:
* `Iterator for ByRefDefault` only forwards the methods that can be used even when the iterator is not `Sized`, all other methods are left to the default.
* `Iterator for ByRef` specializes on `Sized` and forwards to either the underlying iterator or to `ByRefDefault`

This PR also removes `ByRefSized`, the `Iterator for &mut I` should now be good enough to be used everywhere.

Author: joboet

library/alloc/src/collections/vec_deque/mod.rs

@@ -9,7 +9,7 @@
 
 use core::cmp::{self, Ordering};
 use core::hash::{Hash, Hasher};
-use core::iter::{ByRefSized, repeat_n, repeat_with};
+use core::iter::{repeat_n, repeat_with};
 // This is used in a bunch of intra-doc links.
 // FIXME: For some reason, `#[cfg(doc)]` wasn't sufficient, resulting in
 // failures in linkchecker even though rustdoc built the docs just fine.
@@ -477,11 +477,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
             unsafe { guard.deque.write_iter(dst, iter, &mut guard.written) };
         } else {
             unsafe {
-                guard.deque.write_iter(
-                    dst,
-                    ByRefSized(&mut iter).take(head_room),
-                    &mut guard.written,
-                );
+                guard.deque.write_iter(dst, (&mut iter).take(head_room), &mut guard.written);
                 guard.deque.write_iter(0, iter, &mut guard.written)
             };
         }

library/core/src/array/iter.rs

@@ -260,7 +260,7 @@ impl<T, const N: usize> Iterator for IntoIter<T, N> {
         Fold: FnMut(Acc, Self::Item) -> Acc,
     {
         let data = &mut self.data;
-        iter::ByRefSized(&mut self.alive).fold(init, |acc, idx| {
+        (&mut self.alive).fold(init, |acc, idx| {
             // SAFETY: idx is obtained by folding over the `alive` range, which implies the
             // value is currently considered alive but as the range is being consumed each value
             // we read here will only be read once and then considered dead.
@@ -323,7 +323,7 @@ impl<T, const N: usize> DoubleEndedIterator for IntoIter<T, N> {
         Fold: FnMut(Acc, Self::Item) -> Acc,
     {
         let data = &mut self.data;
-        iter::ByRefSized(&mut self.alive).rfold(init, |acc, idx| {
+        (&mut self.alive).rfold(init, |acc, idx| {
             // SAFETY: idx is obtained by folding over the `alive` range, which implies the
             // value is currently considered alive but as the range is being consumed each value
             // we read here will only be read once and then considered dead.

library/core/src/iter/adapters/array_chunks.rs

@@ -1,8 +1,6 @@
 use crate::array;
 use crate::iter::adapters::SourceIter;
-use crate::iter::{
-    ByRefSized, FusedIterator, InPlaceIterable, TrustedFused, TrustedRandomAccessNoCoerce,
-};
+use crate::iter::{FusedIterator, InPlaceIterable, TrustedFused, TrustedRandomAccessNoCoerce};
 use crate::num::NonZero;
 use crate::ops::{ControlFlow, NeverShortCircuit, Try};
 
@@ -128,7 +126,7 @@ where
         self.next_back_remainder();
 
         let mut acc = init;
-        let mut iter = ByRefSized(&mut self.iter).rev();
+        let mut iter = (&mut self.iter).rev();
 
         // NB remainder is handled by `next_back_remainder`, so
         // `next_chunk` can't return `Err` with non-empty remainder