drpc: classify connection-teardown errors at the source

[shubhamdhama]

The idea across this PR is simple: classify an error where it happens, and
only translate it at the edge.

drpc.ToRPCErr is the translator from drpc errors to gRPC status codes, for
callers that work in terms of codes (for example
grpcutil.IsClosedConnection). It only recognizes errors that were already
tagged with a class it knows about: ConnectionError and ClosedError map to
codes.Unavailable (matched even through wrapping), the context and EOF
sentinels map to their own codes (matched by identity), and everything else
becomes codes.Unknown. The boundary has no way to recover intent that was
never attached to the error, so anything that can tear a connection down has to
classify its own error at the source. The edge only translates.

A few teardown paths did not do this and reached the boundary as
codes.Unknown, which defeated the connection-liveness checks. We saw it as a
TestDrain flake under DRPC stream multiplexing: the server kept reporting
"not yet refusing RPC" because the teardown error carried Unknown instead of
Unavailable. With multiplexing a single long-lived connection is reused, so
both the write side and the lifecycle path get exercised in practice.

This PR fixes both I/O directions and the lifecycle path, so that Unknown is
left for genuine faults.

drpcwire: classify write failures as ConnectionError
When MuxWriter's flush to the wire failed, it stored and passed along the raw
*net.OpError (EPIPE), which fell through ToRPCErr to codes.Unknown. Now
the failed write is wrapped in drpc.ConnectionError at its source in
MuxWriter.run, mirroring the read path, so the existing ConnectionError
branch maps it to codes.Unavailable. The underlying error stays in the chain.

drpcmanager: classify teardown errors at the source, by cause
Manager.Close(), which showed up as "manager closed: Close called", and an
abrupt read-side EOF were both unclassified. They are now classified by cause,
never with a catch-all. A Close() means the connection is gone, so it becomes
a ClosedError. A read EOF means the peer hung up, which is a ClosedError for
a client and a context.Canceled for a server, matching how gRPC treats a
client hang-up. Every other reader error is left transparent, so a real
protocol or internal fault still surfaces as Unknown rather than being
mistaken for a retryable connection loss. terminate() now just fans the one
already-classified cause out to everyone, which also fixes a raw-error leak in
NewServerStream. This commit drops the now-dead isConnectionReset.

The pattern is documented where the next person will run into it: ToRPCErr
(the translator and the source-classification rule), the error-class
definitions in drpc.go, and readError in the manager.

[suj-krishnan]

I'm wondering if this should be a catch-all ("gRPC maps every transport failure"), since the net package has other kinds of errors as well. I haven't checked the gRPC code though.

	var netErr net.Error
	if errors.As(err, &netErr) {
		return true
	}

[shubhamdhama]

I've changed the whole way of detecting the connection failure. Right at the source we will appropriately classify the failure.