If this isn't the initial connection, the socket fills up with rtp/rtcp
packets, meaning you can't just read one when you reconnect.
This has terrible implications for voice recv.

I finally found this bug.  Reconnecting sends a none speaking state, so
we need to send speaking again to be heard.

also add ws property

Renamed VoiceClient._voice_state -> ._connection
Renamed ConnectionStage -> ConnectionFlowState (tentatively)
Renamed VoiceConnectionState._stage -> ._state
Renamed VoiceConnectionState.stage -> .state
Renamed parameters called stage -> state
Renamed VoiceConnectionState._wait_for_stage -> ._wait_for_state
Fix VoiceClient.wait_until_connected docstring

Rework ConnectionFlowState from bitfields to normal int enum and fix
relevant comparisons.
Remove obsolete exact param from _wait_for_state
Remove IntEnum typing hack

Since we can only check absolute states now we need to be able to check
for multiple in _wait_for_state

One step towards trying to avoid a very annoying problem with reading
packets from the socket as a shared resource (voice recv)

1. We're changing the socket from implicit connect using sendto to
   explicit connect with sock_connect, and making it use async
   functions while we're at it.

2. We're adding a timeout to the websocket connection+handshake part,
   and also splitting _connect_websocket into two functions, that and
   _handshake_websocket.  Now the ws attribute gets assigned
   immediately after creation and not only after the handshake.

Since there's no way to tell who or what a voice_state_update with
channel=None came from, we have to remember if we were the ones who
disconnected ourselves from the voice channel.  Hopefully this is sane
enough to withstand the average discord eventual consistency.

We switch to force=True by default, and now have a cleanup param to
selectively run voice client cleanup.

The voice socket is no longer directly read from by the voice websocket
to get the ip discovery packet.  Now there is a socket reader thread
object that handles this by using registered callbacks.  This way there
is no longer any for the socket to be improperly shared between any
potential readers.  In the base library this isn't important since the
only thing the socket is read for is the ip discovery packet, but for
*extensions implementing voice recv* its necessary.  The thread pauses
when there are no listeners attached as not to waste cpu time.

Clean up ip discovery future handling
Rename _self_paused to _idle_paused
Misc

Fixing checks and timeouts mostly.  The change to move_to is mostly a
band-aid fix.  It doesn't solve the underlying problem but it removes
that vector for causing it.

By moving connect() to a task we can cancel it and restart, making it
easier to handle overlapping reconnects.  It seems to work from my
testing but i'm not entirely sure its sound, specifically the whole
'stopping the ws runner task' part.  If anything its racy but that
remains to be seen.

There are a bunch of TODOs that need input or a decision on

Remove ip caching, didn't really serve a purpose
Add timeout param to move_to()
Change BlockingIOError to OSError in send_audio_packet()
Change task types to Optional instead of MISSING
Properly transfer connect params and voice state to connect() calls
Remove some uncertain code path handling TODOs
Fix reconnecting in the ws runner task

Raise errors on connection problems
Add default timeout to wait_until_connected
Undocument wait_until_connected (its sync and only used internally once)
Change some timeouts to 30s
Floatify floats

Good thing I remembered to do this or fixing this in my voice recv code
would have been a little annoying.