[suggestion]: Use concrete key types in iroha_crypto

[DCNick3]

(note that this only makes sense to do after the PR for #3422 lands)

Background

For most asymmetric cryptographic algorithm, the keys are not just "an array of bytes" but they actually have some internal structure. Constructing them from bytes requires a parsing step that can fail. Currently we do not reflect this structure in PublicKey and PrivateKey types, storing them as an array of bytes tagged with an algorithm name.

This is unfortunate because we end up copying & deserializing the keys each time we do any cryptographic operation with it. This:

1. might have some performance impact
2. delays the key validation errors to the stage where we actually try to use the key

The suggestion

I suggest to change the key types to instead be something akin to:

pub enum PublicKey {
    Ed25519(ed25519_dalek::VerifyingKey),
    Secp256k1(k256::PublicKey),
    ...
}

In this case the keys are stored in native representations of the crypto traits we use and do not require any conversion to work with. The conversions would now happen at the serialization/deserialization stage.

The smart contract problem

This would, however, require a change to how we treat iroha_crypto in smart contracts. Currently smart contracts can manipulate the cryptographic keys, but cannot do actual cryptographic operations (relying on the host to validate everything for them). Changing the PublicKey type like this would, however, require to actually include at least the parsing part of cryptographic libraries to the smart contracts.

We are, however, focused on reducing the wasm binary size, so this is not feasible as-is.

One solution I can think of is to have separate types for unparsed/parsed key representations. This seems feasible on the surface, but should be investigated further.