Async errors not caught in Node < 10

I'm seeing different behaviour in Node 8 and 9 vs 10, 11 and 12.

The [Node 8 docs](https://nodejs.org/docs/latest-v8.x/api/stream.html#stream_readable_destroy_error) suggest an error is emitted when calling `Readable.prototype.destroy`, however `pump` doesn't propagate the error to the `callback`. e.g.

```js
const { Readable, Writable } = require('stream');
const pump = require('pump');

console.log(process.version);

const readable = new Readable({
read() {
process.nextTick(() => this.destroy(new Error('This
*async* error *is not* caught by `pump` in Node < 10')))
// this.destroy(new Error('This *sync* error *is* caught by `pump` in Node < 10'))
},
});

const writable = new Writable({
write(chunk, encoding, done) {
console.log(chunk);
done();
}
})

pump(readable, writable, (ex) => {
console.log('Finished');
console.error(ex); // undefined in Node < 10
});
```

Surprisingly it can be caught by binding directly to the `readable` error event. e.g.

```js
readable.on('error', (ex) => {
console.log('Error handler', ex); // Error
});
```

Which is why I think it might be an issue with `pump`, rather than Node core?

Start at the pump(readable, writable, callback) entry point and reproduce the provided stream example under Node versions before and after 10. Trace how the readable's asynchronous error reaches the callback; done means the callback receives the error consistently for the affected Node versions.

Written by the indexing model from the issue text.