feat: impl Encode, Decode and Type for Cow<T> where T: Encode + Decode + Type

[JoHaHu]

This allows to use Cow for every T that implements Encode, Decode, and Type.
The motivation for this is that I can use the same struct to decode and encode without having unnecessary copies of data. This is especially helpful in situations where you a have struct for all db tables, since then you would need clone the participating keys of each relation into those structs.

This allows to write this

pub(super) struct TableA<'a> {
  pub(super) id: Cow<'a, Uuid>,
  pub(super) content: Cow<'a, str>,
  ...
}

, instead of this.

// Cannot be used to receive data since decoding into a pointer is not possible, since the Uuid needs to live somewhere
pub(super) struct TableARef<'a> {
  pub(super) id:  &'a Uuid,
  pub(super) content: &'a str,
  ...
}

// Can be used to decode, but encoding requires cloning the data or taking ownership 
pub(super) struct TableA {
  pub(super) id:  Uuid,
  pub(super) content: String,
  ...
}

The implementation for Encode and Type will just delegate to the implementation of T.

The Decode trait is implemented by creating an owned Cow.
The owned variant is used here, because

1. e.g. the query_as function has the bound for<'r> FromRow<'r, DB::Row>.
   This can only be implemented if the lifetime of the type is arbitrary/static, which necessitate the owned variant.
2. the expansion of the query_as! won't work with an object with the same lifetime as the row, which also leads to the owned variant.

I believe that the current impl<'r, DB> Decode<'r, DB> for Cow<'r, str> is broken/ useless, but maybe i've miss the use case for the borrowed variant while decoding.

This implementation currently does not work with the derive macro for FromRow, because the macro implements
impl<'r, R> FromRow<'r, R> for TableA<'r> instead of impl<'r,'a, R> FromRow<'r, R> for TableA<'a>.
But manually implementing FromRow works.

fixed #3100