Implement PeekingNext transitively over mutable references.

This change applies patterns used for the standard `Iterator` trait to
the `PeekingNext` trait. Generic methods require `Self: Sized` and
`PeekingNext` is now transitively implemented over mutable references.
This allows generic code to easily accept owned and mutably borrowed
types that implement `PeekingNext`. This also makes `PeekingNext`
object-safe (though this has little utility today).

src/peeking_take_while.rs

@@ -16,7 +16,18 @@ pub trait PeekingNext : Iterator {
     /// if `accept` returns true, return it as the next element,
     /// else None.
     fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
-        where F: FnOnce(&Self::Item) -> bool;
+        where Self: Sized,
+              F: FnOnce(&Self::Item) -> bool;
+}
+
+impl<'a, I> PeekingNext for &'a mut I
+    where I: PeekingNext,
+{
+    fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
+        where F: FnOnce(&Self::Item) -> bool
+    {
+        (*self).peeking_next(accept)
+    }
 }
 
 impl<I> PeekingNext for Peekable<I>