Introduce tokio-sync crate containing synchronization primitives. (#839)

Introduce a tokio-sync crate containing useful synchronization primitives for programs
written using Tokio.

The initial release contains:

* An mpsc channel
* A oneshot channel
* A semaphore implementation
* An `AtomicTask` primitive.

The `oneshot` and `mpsc` channels are new implementations providing improved
performance characteristics. In some benchmarks, the new mpsc channel shows
up to 7x improvement over the version provided by the `futures` crate. Unfortunately,
the `oneshot` implementation only provides a slight performance improvement as it
is mostly limited by the `futures` 0.1 task system. Once updated to the `std` version
of `Future` (currently nightly only), much greater performance improvements should
be achievable by `oneshot`.

Additionally, he implementations provided here are checked using
[Loom](http://github.com/carllerche/loom/), which provides greater confidence of
correctness.

tokio-sync/src/loom.rs

@@ -0,0 +1,36 @@
+pub(crate) mod futures {
+    pub(crate) use futures::task;
+    pub(crate) use ::task::AtomicTask;
+}
+
+pub(crate) mod sync {
+    pub(crate) use std::sync::atomic;
+
+    use std::cell::UnsafeCell;
+
+    pub(crate) struct CausalCell<T>(UnsafeCell<T>);
+
+    impl<T> CausalCell<T> {
+        pub(crate) fn new(data: T) -> CausalCell<T> {
+            CausalCell(UnsafeCell::new(data))
+        }
+
+        pub(crate) fn with<F, R>(&self, f: F) -> R
+        where
+            F: FnOnce(*const T) -> R,
+        {
+            f(self.0.get())
+        }
+
+        pub(crate) fn with_mut<F, R>(&self, f: F) -> R
+        where
+            F: FnOnce(*mut T) -> R,
+        {
+            f(self.0.get())
+        }
+    }
+}
+
+pub(crate) fn yield_now() {
+    ::std::sync::atomic::spin_loop_hint();
+}