feat: bounds for ser/de derive and schema_params for schema derive attributes

[dj8yfo]

This is logical continuation/conclusion of #178 .

Pr adds possibility to override bounds for BorshSerialize and BorshDeserialize in order to allow not to keep
bounds on type parameters in struct definition itself and fix complex cases, when derive hasn't figured
the right bounds on type parameters automatically, while still not having to implement the traits manually.

/// `T: PartialOrd` is injected into derived trait implementation via field bound to avoid having this restriction on
/// the struct itself
#[cfg(hash_collections)]
#[derive(BorshSerialize)]
struct C1<T, U> {
    a: String,
    #[borsh(bound(serialize = 
        "T: borsh::ser::BorshSerialize + PartialOrd,
         U: borsh::ser::BorshSerialize"))]
    b: HashMap<T, U>,
}

/// `T: PartialOrd + Hash + Eq` is injected into derived trait implementation via field bound to avoid having this restriction on
/// the struct itself
#[allow(unused)]
#[cfg(hash_collections)]
#[derive(BorshDeserialize)]
struct C2<T, U> {
    a: String,
    #[borsh(bound(
        deserialize = 
        "T: PartialOrd + Hash + Eq + borsh::de::BorshDeserialize,
         U: borsh::de::BorshDeserialize"
    ))]
    b: HashMap<T, U>,
}

/// implicit derived `core::default::Default` bounds on `K` and `V` are dropped by empty bound
/// specified, as `HashMap` has its own `Default` implementation
#[cfg(hash_collections)]
#[derive(BorshDeserialize)]
struct G3<K, V, U>(
    #[borsh_skip]
    #[borsh(bound(deserialize = ""))]
    HashMap<K, V>,
    U,
);
// derive here figures the bound erroneously as `T: borsh::ser::BorshSerialize`
#[derive(BorshSerialize)]
struct ParametrizedWronDerive<T, V>
where
    T: TraitName,
{
    #[borsh(bound(serialize = "<T as TraitName>::Associated: borsh::ser::BorshSerialize"))]
    field: <T as TraitName>::Associated,
    another: V,
}

Pr also adds #[borsh(schema(params = ...))] attribute, which may be populated by a list of entries. order_param => override_type.
Such an entry instructs BorshSchema derive to:

1. add override_type to types, bounded by borsh::BorshSchema in implementation block.
2. add <override_type>::declaration() to parameters vector in fn declaration() method of BorshSchema trait that is being derived.
3. the order_param is required to establish the same order in parameters vector (2.) as that of type parameters in generics of type, that BorshSchema is derived for.
4. entries, specified for a field, together replace whatever would've been derived automatically for 1. and 2. .

    // derive here figures the bound erroneously as `T: borsh::BorshSchema`
    // `#[borsh(schema(params = "..."))]` attribute replaces it with <T as TraitName>::Associated: borsh::BorshSchema`
    #[derive(borsh::BorshSchema)]
    struct Parametrized<V, T>
    where
        T: TraitName,
    {
        #[borsh(schema(params = "T => <T as TraitName>::Associated"))]
        field: <T as TraitName>::Associated,
        another: V,
    }

[dj8yfo]

the order has been changed to follow not alphabetic order of types transcription, but
the original order of generics declaration in this commit (as compared to master the pr is being merged on)

[dj8yfo]

Despite work in this commit on filtering relevant WherePredicate-s,
lifetimes in generics aren't filtered according to their actual usage in enum variants, so following example doesn't work:

fn test_enum_with_lifetimes() {
    
    #[allow(unused)]
    #[derive(borsh::BorshSchema)]
    enum EnumParametrized<'a, 'b, T, V>
    {
        A {
            x: BTreeMap<u16, &'a T>,
        },
        B(&'b V, u16),
    }
}

error[E0392]: parameter `'b` is never used
   --> borsh/tests/test_schema_enums.rs:359:31
    |
359 |     enum EnumParametrized<'a, 'b, T, V>
    |                               ^^ unused parameter
    |
    = help: consider removing `'b`, referring to it in a field, or using a marker such as `PhantomData`
                                                                                                                                                                                                                      
error[E0392]: parameter `'a` is never used
   --> borsh/tests/test_schema_enums.rs:359:27
    |
359 |     enum EnumParametrized<'a, 'b, T, V>
    |                           ^^ unused parameter
    |
    = help: consider removing `'a`, referring to it in a field, or using a marker such as `PhantomData`                                                                                                                                                                                                                      

One way to amend this might be to add yet one more attribute to hint relevant generics to derive:

#[test]
fn test_enum_with_lifetimes() {
    
    #[allow(unused)]
    #[derive(borsh::BorshSchema)]
    enum EnumParametrized<'a, 'b, T, V>
    {
        #[borsh(schema(variant_generics = "'a, T"))]
        A {
            x: BTreeMap<u16, &'a T>,
        },
        #[borsh(schema(variant_generics = "'b, V"))]
        B(&'b V, u16),
    }
}

Leaving it as is as of now (not adding borsh(schema(variant_generics = "..."))) as borsh-v0.11.0 isn't able
to handle this case with matching lifetimes against variants either.

 1  error[E0392]: parameter `'b` is never used
    --> borsh/tests/test_schema_enums.rs:218:31
 2  error[E0392]: parameter `'a` is never used
    --> borsh/tests/test_schema_enums.rs:218:27

[dj8yfo]

@iho the following files have been made identical, these contain some functionality shared between borsh-derive-internal and borsh-schema-derive-internal crates. When the unsplit of borsh-derive repo is done, only one copy of each file from borsh-derive-internal is expected to stay.

• unified files:
  • ./borsh-derive-internal/src/generics.rs <=> ./borsh-schema-derive-internal/src/generics.rs
  • ./borsh-derive-internal/src/attribute_helpers.rs => (cut out tests in order not to duplicate snapshots) ./borsh-schema-derive-internal/src/attribute_helpers.rs
  • ./borsh-derive-internal/src/attribute_helpers/parsing_helpers.rs <=> ./borsh-schema-derive-internal/src/attribute_helpers/parsing_helpers.rs