Limit futures dependency to Stream via feature flag (#1774)

In an effort to reach API stability, the `tokio` crate is shedding its
_public_ dependencies on crates that are either a) do not provide a
stable (1.0+) release with longevity guarantees or b) match the `tokio`
release cadence. Of course, implementing `std` traits fits the
requirements.

The on exception, for now, is the `Stream` trait found in `futures_core`.
It is expected that this trait will not change much and be moved into `std.
Since Tokio is not yet going reaching 1.0, I feel that it is acceptable to maintain
a dependency on this trait given how foundational it is.

Since the `Stream` implementation is optional, types that are logically
streams provide `async fn next_*` functions to obtain the next value.
Avoiding the `next()` name prevents fn conflicts with `StreamExt::next()`.

Additionally, some misc cleanup is also done:

- `tokio::io::io` -> `tokio::io::util`.
- `delay` -> `delay_until`.
- `Timeout::new` -> `timeout(...)`.
- `signal::ctrl_c()` returns a future instead of a stream.
- `{tcp,unix}::Incoming` is removed (due to lack of `Stream` trait).
- `time::Throttle` is removed (due to lack of `Stream` trait).
-  Fix: `mpsc::UnboundedSender::send(&self)` (no more conflict with `Sink` fns).

tokio/tests/time_interval.rs

@@ -1,12 +1,14 @@
 #![warn(rust_2018_idioms)]
 
-use tokio::time::{self, Duration, Instant, Interval};
+use tokio::time::{self, Duration, Instant};
 use tokio_test::{assert_pending, assert_ready_eq, task};
 
+use std::task::Poll;
+
 #[tokio::test]
 #[should_panic]
 async fn interval_zero_duration() {
-    let _ = Interval::new(Instant::now(), ms(0));
+    let _ = time::interval_at(Instant::now(), ms(0));
 }
 
 #[tokio::test]
@@ -18,26 +20,44 @@ async fn usage() {
     // TODO: Skip this
     time::advance(ms(1)).await;
 
-    let mut int = task::spawn(Interval::new(start, ms(300)));
+    let mut i = task::spawn(time::interval_at(start, ms(300)));
 
-    assert_ready_eq!(int.poll_next(), Some(start));
-    assert_pending!(int.poll_next());
+    assert_ready_eq!(poll_next(&mut i), start);
+    assert_pending!(poll_next(&mut i));
 
     time::advance(ms(100)).await;
-    assert_pending!(int.poll_next());
+    assert_pending!(poll_next(&mut i));
 
     time::advance(ms(200)).await;
-    assert_ready_eq!(int.poll_next(), Some(start + ms(300)));
-    assert_pending!(int.poll_next());
+    assert_ready_eq!(poll_next(&mut i), start + ms(300));
+    assert_pending!(poll_next(&mut i));
 
     time::advance(ms(400)).await;
-    assert_ready_eq!(int.poll_next(), Some(start + ms(600)));
-    assert_pending!(int.poll_next());
+    assert_ready_eq!(poll_next(&mut i), start + ms(600));
+    assert_pending!(poll_next(&mut i));
 
     time::advance(ms(500)).await;
-    assert_ready_eq!(int.poll_next(), Some(start + ms(900)));
-    assert_ready_eq!(int.poll_next(), Some(start + ms(1200)));
-    assert_pending!(int.poll_next());
+    assert_ready_eq!(poll_next(&mut i), start + ms(900));
+    assert_ready_eq!(poll_next(&mut i), start + ms(1200));
+    assert_pending!(poll_next(&mut i));
+}
+
+#[tokio::test]
+async fn usage_stream() {
+    use futures::StreamExt;
+
+    let start = Instant::now();
+    let mut interval = time::interval(ms(10));
+
+    for _ in 0..3 {
+        interval.next().await.unwrap();
+    }
+
+    assert!(start.elapsed() > ms(20));
+}
+
+fn poll_next(interval: &mut task::Spawn<time::Interval>) -> Poll<Instant> {
+    interval.enter(|cx, mut interval| interval.poll_tick(cx))
 }
 
 fn ms(n: u64) -> Duration {