buffer: wake tasks waiting for channel capacity when terminating

[hawkw]

Depends on #479

#476 introduces one regression in buffer: tasks waiting for a
buffer::Service to become ready (in poll_ready) are no longer
notified when the buffer worker task terminates or the inner service
fails. This means that if a buffer is over its channel capacity, and
tasks are waiting for it to become ready again, and the buffered service
fails before sufficient channel capacity is released to wake those
tasks, those tasks are effectively leaked. They will never become ready.

This is because we are no longer using Tokio's bounded MPSC channel, and
are instead implementing our own bounded channel on top of the unbounded
MPSC using a semaphore. While the bounded MPSC sender's poll_ready
method would notify waiting tasks when the receiver is dropped, that
method no longer exists in Tokio 0.3, and we have to use an external
semaphore to provide a polling based API for waiting for channel
capacity. The semaphore does not wake pending tasks because it must live
in an Arc in order for the Semaphore::acquire_owned method to be
useable, and thus it will never be dropped while there are waiting
tasks. Not dropping the semaphore is necessary to uphold the safety
invariants of the intrusive wait list, but it means that the tasks will
not be woken by the semaphore being dropped.

This branch fixes this issue by adding the ability to wake all tasks
waiting on a semaphore by adding close to the maximum allowed number of
permits to it. This should be sufficient to wake all waiters, but it's
a little bit janky. The ideal solution would be for Tokio to expose the
close method on the internal semaphore implementation in a public API.
However, this works now without requiring an upstream change.

I've also added tests for this behavior.