stream2: flush extant data on read of ended stream

A ReadableStream with a base64 StringDecoder backed by only
one or two bytes would fail to output its partial data before
ending. This fix adds a check to see if the `read` was triggered
by an internal `flow`, and if so, empties any remaining data.
    
Fixes #7914.
The original reason `state.flowing` was here (and was eventually replaced by a check for `state.decoder` is that [there's a test](https://github.com/joyent/node/blob/v0.10/test/simple/test-stream2-basic.js#L403) that specifies that `read(0)` on an ended stream should not return a buffer. `flowing` was a better proxy for `read(undefined)` (or `read()`), but didn't quite get at the heart of the matter -- in my understanding: that test asserts that a `state.ended` stream *cannot* emit any further data. After these changes are applied, it *can*, but only if the data that would be emitted is produced by `state.decoder` as a result of receiving an EOF.

The sequence of events is:

1. A chunk comes in (via `push`) that, when put through `StringEncoder`, produces a **zero length buffer** & sets up a state in the decoder where ending will produce a new chunk.
2. An EOF arrives. This flushes the [remaining data out of the string encoder *into* the state.](https://github.com/joyent/node/blob/v0.10/lib/_stream_readable.js#L371-L378)
3. Since there's data in `state.buffer`, `'readable'` is [emitted](https://github.com/joyent/node/blob/v0.10/lib/_stream_readable.js#L383).
4. The [pipeline](https://github.com/joyent/node/blob/v0.10/lib/_stream_readable.js#L555) triggers a [`flow`](https://github.com/joyent/node/blob/v0.10/lib/_stream_readable.js#L572).
5. `flow` causes a [`read()`](https://github.com/joyent/node/blob/v0.10/lib/_stream_readable.js#L588).
6. in `howMuchToRead`, we coerce `n = 0` because we're flowing and we look at the length of the [first buffer we have stored](https://github.com/joyent/node/blob/v0.10/lib/_stream_readable.js#L224). This turns out to be **length zero**. 
7. We go into a [bad state](https://github.com/joyent/node/blob/v0.10/lib/_stream_readable.js#L273-L277) since we're reading `0` and `ended`. The stream never flushes the data.

To summarize: StringDecoder produces an empty buffer, puts it into `state.buffer`, puts more data into `state.buffer` on EOF, then `howMuchToRead` returns 0 because it looks at that first empty item, causing the stream to never flush the decoder data. The fix can either exist in `read`, `howMuchToRead`, or `readableAddChunk` -- alternate solutions are given [here](https://gist.github.com/chrisdickinson/7aedbd381a52612bb616). 

I opted out of the `howMuchToRead` case because it will be called more than `read` itself (potentially twice per `read`), and `readableAddChunk` because it would incur an additional check per `push` (vs. hiding the new check behind an existing check that should happen only once at the end of a stream).