[Feature] Turn SolCall::Return into Tuple

[MartinquaXD]

Component

sol! macro

Describe the feature you would like

Over all I really like the ergonomics of using the sol! macro! 👏
The only thing that currently seems odd is that the return type is a struct instead of a tuple.

So specifically this code:

alloy_sol_types::sol! {
    function example() external returns (uint256, uint256);
}

Roughly results in this return type:

struct exampleReturn {
    pub _0: UInt<256, 4>,
    pub _1: UInt<256, 4>,
}

whereas a return type like this seems more natural to use:

struct exampleReturn (
    UInt<256, 4>,
    UInt<256, 4>,
)

Maybe having the type as a struct is nicer for the internal library code. But in that case at least having a function like into_tuple() would be nice.

Additional context

For context I wanted to have a generic function like this which should immediately return the tuple instead of the struct:

pub async fn call<T: SolCall>(web3: &Web3, to: H160, call: T) -> Result<T::Return, CallError> {
    let call = CallRequest {
        to: Some(to),
        data: Some(Bytes(call.abi_encode())),
        ..Default::default()
    };
    let rpc_response = web3.eth().call(call, None).await.map_err(CallError::Rpc)?;
    if rpc_response.0.is_empty() {
        return Err(CallError::MissingFunction);
    }
    T::abi_decode_returns(&rpc_response.0, true).map_err(CallError::Decode)
}

[MartinquaXD]

Shortly after opening the issue I noticed that you already support named function arguments and return tuple fields so this is less of an issue for me now.
But supporting tuples would still be cool.

[DaniPopes]

I don't believe this is something we should add, as currently all structures have consistent naming schemes in all circumstances. Similar to #580.