Refactor `ConversionError` enum

[sergerad]

As per comment:

split this error up somehow into more logically grouped variants (right now, it mixes account-related, note-related, SMT-related etc. errors together).

Should be done after #1521 is merged.

[Mirko-von-Leipzig]

Ideally I think we shouldn't have a single ConversionError, but instead an error enum per type.

But that will require a bit of a more though and design - ideas are welcome. Until then cleaning up this massive error blob is maybe worth the effort if it doesn't take more than a day (imo).

---

What I'd love to end up with is something like this. However that's a more overarching design, and I haven't thought hard about how errors should be composed.

/// A gRPC server method implementation.
trait GrpcMethod {
    type GrpcRequest;
    type GrpcResponse;
    type Error;
    type Request: GrpcDecode<Self::GrpcRequest>;
    type Response: GrpcEncode<Self::GrpcResponse>;

    async fn handle(&mut self, request: Self::Request) -> Result<Self::Respond, Self::Error>;

    async fn full(&mut self, request: &Self::GrpcRequest) -> Result<Self::GrpcResponse, GrpcError<Self>> {
        // TODO: create a span for each of these steps so we can measure encoding/decoding time.
        let request = Self::Request::decode(request)
            .map_err(GrpcError::Decoding)?;

        let response = self.handle(request).await
            .map_err(GrpcError::Handler)?;

        response.encode().map_err(GrpcError::Encoding)
    }
}

// TODO: somehow this should be composable. But maybe that's just a bit of manual effort.
trait GrpcDecode<Raw> {
    type Error;
    
    fn decode(raw: &Raw) -> Result<Self, Self::Error>;
}

enum GrpcError<Method: GrpcMethod> {
    Decoding(<Method::Request as GrpcDecode>::Error),
    Encoding(<Method::Request as GrpcEncode>::Error),
    Handler(Method::Error),
}

[bobbinth]

Copying from #1446:

Avoid using #[from] in ConversionError, use #[source] instead and map errors explicitly using map_err.

If it makes sense, consider avoiding AssetError(AssetError) and create more explicit variants like (imaginary) AssetCreationFailed(AssetError) and AssetBurnFailed(AssetError), etc.

Context: #1440 (comment).