feat!: define error codes in an enum and expose them in new variants

[Frando]

This continues the work started in #130 and makes things fully consistent. It properly separates error codes between ones for requests and for channel messages, and exposes the stream resets properly in the corresponding RecvErrors. It adds new error variants and proper docs around them, stating clearly who causes which kind of failure.

Notes and open questions

I'm not super sure if all of them provide much value downstream, but this now fully expresses all variants that we support, and I think it is good to provide consistency in these errors and variants now. If we think it is too much, we can collapse some, but I'd still like to keep the proper error codes. IMO, having these variants doesn't hurt, and to me it feels correct to support all cases properly.

Breaking changes

All these changes only concern you if you match on specific error cases. If not all code continues to work as previously.

• removed: the public constants rpc::ERROR_CODE_MAX_MESSAGE_SIZE_EXCEEDED, ERROR_CODE_ENCODE_FAILED, ERROR_CODE_DECODE_FAILED, and ERROR_CODE_ABORTED. Use the new rpc::ErrorCode enum with to_code and from_code.
• changed: SendError::MaxMessageSizeExceeded and {mpsc,oneshot}::RecvError::MaxMessageSizeExceeded are renamed to MaxSizeExceeded. Each side now gets it only if it found the too large message itself. The other side gets Remote { code: ErrorCode::MessageMaxSizeExceeded }.
• changed: WriteError::MaxMessageSizeExceeded is renamed to MaxSizeExceeded, and the client gets it only if it found the too large request itself. WriteError::Io (which held encode failures) is now EncodeFailed, and WriteError::Noq is replaced by WriteError::Io with an io::Error.
• changed: ReadRequestError::MaxMessageSizeExceeded and InvalidRequest are renamed to MaxSizeExceeded and Malformed.
• added: Remote { code: ErrorCode } on SendError, {mpsc,oneshot}::RecvError, and WriteError, for an irpc error code that the peer reset or stopped the stream with. Before, these cases were Io errors.
• added: SendError::EncodeFailed and {mpsc,oneshot}::RecvError::DecodeFailed, for a message that this side could not encode or decode. Before, these cases were Io errors.
• added: remote_code() on SendError, {mpsc,oneshot}::RecvError, WriteError, and irpc::Error. It returns the irpc error code that the peer sent, from a Remote error or from the close of the connection.

Behavior changes:

• the error codes are renumbered, requests first: 0 Closed, 1 RequestAborted, 2 RequestMaxSizeExceeded, 3 RequestEncodeFailed, 4 RequestDecodeFailed, 5 MessageMaxSizeExceeded, 6 MessageEncodeFailed, 7 MessageDecodeFailed. Before, codes 1 to 3 meant too large, encode failed, and decode failed for both requests and channel messages, and code 4 was aborted.
• server rejects a bad request with RequestMaxSizeExceeded or RequestDecodeFailed on both streams and for the connection close. Before, it used code 1 (too large) or code 3 (does not decode).
• a client that cannot encode its request resets the stream with RequestMaxSizeExceeded or RequestEncodeFailed instead of RequestAborted.
• when the server skips a request whose stream the client reset, it resets its side of the stream with RequestAborted instead of code 0.
• a Remote error converts to an io::Error with ConnectionReset, as the reset or stop did before. The other new variants convert with InvalidData. A reset or stop with code 0 stays an Io error, except that a sender still gets ReceiverClosed.
• after a remote send fails, later sends on the sender and its clones get the same error if the receiver ended the channel, and Io(BrokenPipe) if this sender closed it, for example after an io error, a message that does not encode or is too large, or a cancelled send.

[rklaehn]

🤖 In read_request_inner, the ReadFrame::Reset branch now just continues, and dropping send finishes the response stream. If an update fails to encode, its reset can overtake the request, so the server skips it, and a client with an mpsc response then gets Ok(None) (looks like a clean completion) instead of an error. Suggest send.reset(ErrorCode::RequestAborted.into()).ok(); before continue, plus an mpsc variant of reset_before_read_skips_request.