It has been deprecated for some time.

The API needs to be abstract, so make p256k1 signature
an associated type of CryptoProvider.

Guarded by the rust-crypto feature, this is an implementation of
CryptoProvider with pure Rust crates.

Move CryptoProvider definition out of the crypto module into
the provider sub-module. Rename default_provider to default.

Add generic methods Header::hash_with and ValidatorSet::hash_with
enabling a custom CryptoProvider to be plugged in for calculating
hashes.
The .hash() methods, implemented with the DefaultCryptoProvider,
are feature-gated behind "rust-crypto".

2usize.next_power_of_two() / 1 == 1, and we have eliminated the other
two explicitly matched cases at the call site, so the non-catchall
match branches and the panics are dead code.

The Hasher trait is obviated by CryptoProvider.
Also, we could do with less dynamic dispatching.

Instead of a super-trait whose sole purpose is to bind down some
associated types that provide the actual functionality, provide:
- Sha256, a purpose-specific trait for SHA256 hashing that has
  a more human-friendly interface than rust-crypto.
- Nothing else for signing and verifying! These are covered by the
  signature framework, and it's easy to plug into that as the
  alt_crypto test demonstrates.

The crypto::default module, gated by the "rust-crypto" feature,
provides aliases for pure Rust implementations.

An alt implementation would not be able to reuse the signature
type from k256.

Remove the only purpose for using a hasher in the implementation
by returning the set of validators in
VerificationErrorDetail::FaultySigner.

CommitValidator can now revert to being a (weird) default-implemented
trait, with a ProdCommitValidator to anchor the implementation.

A critical code block was hastily commented out in this
"unstable" part of code.

Use the Sha2 alias from crypto::default instead of the direct
references to sha2 crate. All code that used Sha2 non-generically
is feature-gated behind "rust-crypto".

The host API for obtaining SHA256 digests on Substrate is a simple
function, it cannot work incrementally. Change the Sha256 trait to
match this, but provide a MerkleHash trait to retain incremental
Merkle hashing with Rust-Crypto conformant digest implementations.
The merkle::NonIncremental adapter type is provided to fit the lowest common
denominator Sha256 API to a Merkle hash implementation, at the
cost of some allocations and extra copying.

Also rename crypto::default::ecdsa_secp256 to ecdsa_secp256k1,
to harmonize the naming with the feature that gates this module.

Needed for NodeKey.

Define Verifier trait to abstract signature verification given a
PublicKey.

The ed25519-consensus dependency is made optional and gated by the
"rust-crypto" feature.
The Verifier implementation is provided for a dummy type
crate::crypto::default::signature::Verifier, using ed25519-consensus.
The Ed25519 key types in public_key and private_key module are redefined
to in-crate newtypes.

As we don't currently use the signature framework, it makes no
sense to provide its traits through the crate.

Implement the new Verifier trait instead of the signature traits.