Add async send/recv to TcpConn (#2056)

[rmahidhar]

Summary:

Refactor TcpConn into a policy-based template TcpConn<IOPolicy> and add
epoll-driven async send/recv for non-blocking data and control plane
messaging on the EventBase thread.

Design

Policy-based TcpConn:

• TcpConn<SyncIO> — sync-only, no EventBase dependency, zero
  overhead via [[no_unique_address]]
• TcpConn<AsyncIO> — sync + async, holds EventBase& and all async
  state (SendState, RecvState) in the AsyncIO policy struct
• Async methods use C++20 requires clauses — calling async on a
  TcpConn<SyncIO> is a compile error, not a runtime error
• Follows the same policy pattern as TcpServer<AcceptPolicy> and
  TcpClient<ConnectPolicy>

Asio-style dual overloads:

Send:

• asyncSend(std::span<const uint8_t>) — zero-copy, caller keeps
  buffer alive until the future resolves
• asyncSend(std::vector<uint8_t>) — TcpConn takes ownership via move

Recv:

• asyncRecv(std::span<uint8_t>) — zero-copy into caller's
  pre-allocated buffer; error if payload exceeds buffer size
• asyncRecv() — allocating recv, returns the payload vector

Usage

// Create async-capable connection
auto conn = TcpConn<AsyncIO>::create(sock, evb);

// Data path: zero-copy send (caller keeps buffer alive)
std::vector<uint8_t> data = ...;
auto f = conn->asyncSend(std::span<const uint8_t>(data));
auto result = f.get();

// Control path: TcpConn takes ownership
auto f = conn->asyncSend(std::vector<uint8_t>{'H', 'I'});

// Data path: zero-copy recv into pre-allocated buffer
std::vector<uint8_t> buf(4096);
auto f = conn->asyncRecv(std::span<uint8_t>(buf));
size_t n = f.get().value();

// Control path: allocating recv
auto f = conn->asyncRecv();
std::vector<uint8_t> payload = f.get().value();

Implementation

• Length-prefixed framing (4-byte network-order header + payload)
• asyncSendImpl — shared dispatch for both send overloads; span is
  re-pointed after the final move into sendState to prevent dangling
• RecvState::setError/complete/target — centralize span-vs-alloc
  branching, eliminating scattered isSpanMode checks
• trySend/tryRecv — non-blocking I/O with tri-state return
  (done / EAGAIN / error)
• Eager send/recv — onSendReady/onRecvReady called in the dispatch
  lambda before registering with epoll, allowing small messages to
  complete without an epoll round-trip
• poisonConnection — on protocol errors (oversized message, span too
  small), shuts down the socket with SHUT_RDWR to prevent future I/O
  on a desynchronized stream while keeping the fd valid for deferred
  unregisterFd
• Destructor synchronizes with EventBase via dispatchAndWait + drain
  to prevent use-after-free from IO callbacks capturing this
• One in-flight operation per direction; concurrent attempts return
  ResourceExhausted

Differential Revision: D97788124

[meta-codesync]

@rmahidhar has exported this pull request. If you are a Meta employee, you can view the originating Diff in D97788124.