net/transport: fix yamux dial fd-reuse race and outgoing sub-stream leak

H1: yamux Dial installed a net.Dialer.Control that, on ctx cancellation,
called Shutdown+Close on the raw socket fd. DialContext(ctx) already aborts
the connect and closes its own fd, so the two raced to close the same fd
number (classic fd-reuse hazard). Drop the Control/abortOnCancel machinery
and the abort_{unix,windows,other}.go files; rely on net.Dialer.Timeout +
DialContext(ctx), which handle timeout and cancellation safely.

H2: peer.openDrpcConn opened a sub-stream then ran OutgoingProtoHandshake,
returning the error without closing the stream. The handshake does not close
the conn on three protocol-level error paths (incompatible/declined/
unexpected proto), so a version-skewed peer leaked streams unboundedly. Close
the sub-stream on any handshake error, matching the incoming serve() path.

Refs GO-7313

Author: requilence

net/peer/peer.go

@@ -275,6 +275,11 @@ func (p *peer) openDrpcConn(ctx context.Context) (*subConn, error) {
 	lastUsageConn := connutil.NewLastUsageConn(conn)
 	proto, err := handshake.OutgoingProtoHandshake(ctx, lastUsageConn, defaultHandshakeProto)
 	if err != nil {
+		// OutgoingProtoHandshake closes the conn on I/O errors and ctx
+		// cancellation, but returns without closing on some protocol-level
+		// errors (incompatible/declined/unexpected proto). Close here so the
+		// sub-stream we opened above never leaks. Double close is harmless.
+		_ = lastUsageConn.Close()
 		return nil, err
 	}
 	bufSize := p.ctrl.DrpcConfig().Stream.MaxMsgSizeMb * (1 << 20)

net/transport/yamux/abort_other.go

@@ -104,24 +104,19 @@ func (y *yamuxTransport) AddListener(lis net.Listener) {
 
 func (y *yamuxTransport) Dial(ctx context.Context, addr string) (mc transport.MultiConn, err error) {
 	dialTimeout := time.Duration(y.conf.DialTimeoutSec) * time.Second
-	
-	// Setup abort mechanism for context cancellation
-	done := make(chan struct{})
-	
+	// net.Dialer.Timeout together with DialContext(ctx) already aborts the TCP
+	// connect on timeout or ctx cancellation and closes the underlying fd
+	// through the runtime. We must not abort the socket ourselves: closing the
+	// raw fd that the netpoller owns races with that cleanup and can close an
+	// unrelated, reused descriptor.
 	dialer := &net.Dialer{
 		Timeout: dialTimeout,
-		Control: controlFunc(ctx, done),
 	}
-	
 	conn, err := dialer.DialContext(ctx, "tcp", addr)
-	
-	// Signal the abortor goroutine to exit
-	close(done)
-	
 	if err != nil {
 		return nil, err
 	}
-	
+
 	ctx, cancel := context.WithTimeout(ctx, dialTimeout)
 	defer cancel()
 	cctx, err := y.secure.SecureOutbound(ctx, conn)