Emits `finish` dispite still consuming

Nobody has claimed this yet.

The following code is a copy of an example in README **plus** `finish` event. I assumed the parallel transform emits `finish` after all data consumption but is didn't.

```javascript
var stream = transform(10, function (data, callback) {
setTimeout(function () {
callback(null, data);
}, Math.random() * 1000);
});

for (var i = 0; i < 10; i++) {
stream.write('' + i);
}
stream.end();

stream.on('finish', function () {
console.log('stream has finished');
});
stream.on('end', function () {
console.log('stream has ended');
});
```
output
```
0
stream has finished
1
2
3
4
5
6
7
8
9
stream has ended
```

This is not pleasant especially when we use libs such as `pump` that calls a callback function depending on `finish` event.

It seems that it emits `finish` **after all writable data is buffered** instead of consumed.

This problem occurs also in `parallel-stream` module.

Also, when we do `readable.pipe(parallelTransform).pipe(writable)`, the writable emits `finish` earlier than expected.

Start with the README example and run the reproduction shown in the issue to observe the finish and end event ordering. Then trace the transform stream's writable and readable event handling, including the reported parallel-stream and pump interactions. Done means the event sequence reflects consumption completion and the piped writable no longer finishes prematurely.

Written by the indexing model from the issue text.