transport/zeromq + channel + minion: async close for req channel reconnect

[dwoz]

Fixes the root-cause race behind the pyzmq Context.__del__ wedge in the minion's reconnect path.

The wedge captured live on a production-shape minion had this shape:

RequestClient._init_socket -> self.context = zmq.asyncio.Context()
...
Minion.handle_event / connect_master reconnect fires:
    self.req_channel.close()      # runs on the ioloop thread
    self.req_channel = None
...
~200 s later, Context.__del__ fires from an ioloop callback,
calls destroy() -> zmq_ctx_term(), and the loop wedges
indefinitely.

RequestClient.close()'s same-thread + loop-running branch cannot await the running _send_recv task (blocking would deadlock the loop it is on), so it runs _sync_teardown immediately and returns. _send_recv may still be holding a reference to the socket in its coroutine locals when that teardown runs; the socket holds a reference to the context; and so the context refcount does not drop to zero when close() returns. When _send_recv finally exits and drops its socket reference, Python's GC finalizes the Context -- from an ioloop callback -- and pyzmq's default __del__ walks the remaining sockets under their native LINGER, wedging the loop in zmq_ctx_term().

Three coordinated changes:

• RequestClient.close_async(): new coroutine that fires the shutdown sentinel, awaits _send_recv_exit_future, then releases socket + context deterministically. Context is destroyed with linger=1000 -- bounded rather than open-ended, but generous enough that any in-flight REQ traffic on the socket the context still tracks can flush.

• AsyncReqChannel.close_async(): new coroutine that awaits self.transport.close_async() when available and falls back to sync close() for transports (e.g. TCP) without it. __aexit__ switched over to the async variant so the same race does not resurface in async with teardown.

• salt.minion reconnect sites (connect_master and the master-changed branch of handle_event): both switched from sync self.req_channel.close() to await self.req_channel.close_async() before the self.req_channel = None assignment. A getattr guard keeps the reconnect code compatible with third-party channel subclasses that only expose the sync close.

Existing sync close() behaviour is left unchanged for callers that cannot yield or are not on an ioloop -- the async path is strictly additive. Local test verification: regression suite (test_context_finalizer_wedge), tests/pytests/unit/transport/ (256/2/3), and tests/pytests/unit/channel/ (60/0/0) all pass.