Promise streams

All specs pass.

Implemented `Readable` as an abstract interface that provides `forEach`,
`map`, `reduce`, `buffer`, `all`, `copy`, and `read` for any
implementation that provides the asynchronous iterator method, `next`.
Readable makes use of a semaphore `Queue` and a `Pipe` to control
back-pressure based on user-given or methd-specific-default parallelism
limits.

Implemented a `Reader` stream that wraps an array or any object, local
or remote, that provides a `next` method, including iterators and
generator iterators.  Thus, a stream can lazily consume an indefinite
iteration.

Brought in a cleaner implementation of the indefinite promise `Queue`.
This implementation lacks the `close` and `closed` hacks that exist in
the current `q/queue`, which will likely be removed when these changes
get traction, particularly in Q-Connection.

Implemented a `BufferStream`, backed by a `Queue`, that provides both
`Reader` and `Writer` interfaces, as well as an acknoweldgement channel.
`put` returns a promise for when `get` has been consumed.

The Node.js stream reader has been reimplemented based on the latest
rendition of Node.js streams and the new `StreamBuffer`, so promise
streams send back pressure down to the underlying system.  Cosmetic
changes only to `Writer`.

Created a separate mock file stream, which manages an internal `chunks`
array which can be reused on mock file system nodes between reads and
writes.  This turned out to be different enough from `Reader` and
`BufferStream` that a different implementation was needed.  The old
`BufferStream`, originally used by the mock file system has gone away.

Special cases in the HTTP server have been removed, leaving a clean
interface that handles all cases including new streams for bodies.

Ported `WebStream`, by factoring the stream adapter in Q-Connection
together with the new `BufferStream`.  The new streams model connection
closing much more elegantly.  `WebStream` is idempotent and can wrap
`MessageChannel` ports, `WebWorker`, and `WebSocket`.  Q-Connection will
eventually be refactored to take advantage of `WebStream`.

Created `WindowStream`, using code contributed to Q-Connection by
@johnjdalton two years ago.  Window streams are useful for establishing
bidirectional connections between windows and frames.  WindowStream is
not a constructor, but has `listen` and `connect` methods.  `listen`
returns a stream of streams, which can be closed to shut down.
`connect` returns a stream that will buffer and pipe messages when and
if the connection is established.