several tweaks to better support high-resolution screen capture and testing

 * don't resize input frames to a "standard" WebRTC resolution

 * make SrtpSession::Init public so we can call it before any peers
   are created and thereby avoid a data race

 * make PacedSender::ShouldSendNextPacket notify listener that the
   queue has been flushed.  This allows us to throttle frame creation
   so we don't get ahead of the network and introduce unecessary
   latency.  It's a total hack, though, since it only allows one
   listener per process, whereas we would preferably support multiple
   peers, each listening to its own PacedSender.

 * use the default vp8 config instead of overriding the defaults.  CBR
   does not seem to work as well for screen content, and none of the
   other overrides seem to add any value -- this may be worth
   revisiting, though.

 * don't delay rendering video frames on the decode side.  This
   speeds up the integration test by avoiding added latency, but would
   have no effect on a stand-alone screen capture program, since it
   wouldn't include a decoder.
add support for registering multiple ecovate::Listener instances

ecovate::Listener is a hack to allow us to listen for certain events
that the WebRTC stack doesn't ordinarly report to the application,
such as when the network layer is ready to send and when it's ready
for more data.  Ideally, we'd pass this listener all the way down the
stack, but that would require changing a lot of code, so we use a
hack: acquire a global lock and update a global reference to the
desired listener before calling PeerConnection::SetLocalDescription,
then clear the global reference and global lock.  That way, each
instance of PeerConnection gets a listener appropriate to that
listener, whereas the previous implementation only worked if there was
only one PeerConnection per process.

This commit also includes a couple of minor changes to ensure every
frame the application gives to the WebRTC stack makes it all the way
to the network (e.g. no frame dropping and no multithreading-induced
nondeterminism).  This makes writing a reliable integration test much
easier and aids debugging.