Add DefaultParams to allow more transaction extensions to be used when calling _default() methods

[jsdw]

We currently rely on extrinsic parameters implementing Default on these two methods of TxClient:

    pub async fn sign_and_submit_then_watch_default<Call, Signer>(
        &mut self,
        call: &Call,
        signer: &Signer,
    ) -> Result<TxProgress<T, C>, Error>
    where
        Call: Payload,
        Signer: SignerT<T>,
        <T::ExtrinsicParams as ExtrinsicParams<T>>::Params: Default, // <-- here
    {
        self.sign_and_submit_then_watch(call, signer, DefaultParams::default_params())
            .await
    }

    pub async fn sign_and_submit_default<Call, Signer>(
        &mut self,
        call: &Call,
        signer: &Signer,
    ) -> Result<T::Hash, Error>
    where
        Call: Payload,
        Signer: SignerT<T>,
        <T::ExtrinsicParams as ExtrinsicParams<T>>::Params: Default, // <-- here
    {
        self.sign_and_submit(call, signer, DefaultParams::default_params())
            .await
    }

Extrinsic params are, by default, a tuple containing an entry for each transaction extension configured via AnyOf. Our default transaction extensions are this:

transaction_extensions::AnyOf<
    T,
    (
        transaction_extensions::VerifySignature<T>,
        transaction_extensions::CheckSpecVersion,
        transaction_extensions::CheckTxVersion,
        transaction_extensions::CheckNonce,
        transaction_extensions::CheckGenesis<T>,
        transaction_extensions::CheckMortality<T>,
        transaction_extensions::ChargeAssetTxPayment<T>,
        transaction_extensions::ChargeTransactionPayment,
        transaction_extensions::CheckMetadataHash,
    ),
>;

And AnyOf is implemented such that the parameters to configure each extension are expected in a tuple with a size matching the extensions above.

We currently have support for 9 default transaction extensions above, but if this number were to exceed 12 (which is the max tuple size that Rust implements Default for), then we could no longer use AnyOf in conjunction with our _default methods, since the parameters would no longer implement Default.

So, we add a DefaultParams trait instead, which supports up to 26 entries in the tuple (as long as each of those impls Default), matching the number of tuple entries AnyOf supports.

The downside is that a user going off the beaten path will need to implement DefaultParams instead of Default for their own params if they want to use the _default methods, but this is likely to be a rare case.

Closes #1975.

[gui1117]

Looks good to me