Move handler writing flow control to serve goroutine's frame scheduler.

Previously the 'flow' type had a sync.Cond+Mutex and it was the
Handler goroutine that blocked on large writes, waiting for a suitable
number of flow controlled bytes to Write. Now a Handler goroutine
writes as much as it wants (it already had it in memory already),
still typically bounded to its bufio.Writer size, and it's the serve
goroutine's frame scheduler that's responsible for cutting them up
into suitably-sized DATA frames, and figuring out prioritization, and
even cutting those DATA frames up into smaller bits. (There can still
only be one Write, however large, active at a time from
Handlers... the Handler blocks waiting for its whole Write to
complete)

This change is now possible because of the changes made in f16a0b35
that added visibility into what was being written by adding the
writeFramer interface type. Now we can type-assert the 'writeData'
type and modify it as needed if it's too big for what we're allowed to
write.

Future changes will improve the frame scheduler to deal with stream
priorities, and notably now be able to cut weightedly divide write
resources when several streams have pending data and have no dependent
streams. (Because now the frame scheduler has more visibility into
everything that was pending, whereas before that knowledge was locked
up inside the goroutine that was blocked on the *flow).