Is your feature request related to a problem? Please describe.
viem has a really nice feature where consecutive calls are held in a queue then automatically batched using Multicall3. As you can see from the docs, this enables really nice UX such as:

const contract = getContract({ address, abi })

// The below will send a single request to the RPC Provider.
const [name, totalSupply, symbol, tokenUri, balance] = await Promise.all([
  contract.read.name(),
  contract.read.totalSupply(),
  contract.read.symbol(),
  contract.read.tokenURI([420n]),
  contract.read.balanceOf([address]),
])

This UX is much better than manually configuring the multicall. And a multicall results in significantly better performance and reduced RPC bills compared to individual calls

The other motivation for asking this is related to upstream usage in foundry. When users write forge tests or scripts, they'll often make many view calls to fetch data from the chain. Currently each call is a single RPC request, so you quickly end up with a lot of RPC calls, resulting in throttling and slower tests.

Supporting this feature and leveraging it in forge can result in significantly faster fork tests and scripts.

Describe the solution you'd like
I'm not sure how feasible a viem-like solution is in rust, but that's the ideal solution here: abstract away the need for users to worry about multicall but automatically batching calls, e.g. the below should be a single RPC call:

// Currently the below snippet would send 5 RPC requests to the provider, but ideally
// it should just send a single multicall request.
let (name, total_supply, symbol, token_uri, balance) = tokio::try_join!(
    contract.method::<_, String>("name", (), None)?.call(),
    contract.method::<_, U256>("totalSupply", (), None)?.call(),
    contract.method::<_, String>("symbol", (), None)?.call(),
    contract.method::<_, String>("tokenURI", (U256::from(420),), None)?.call(),
    contract.method::<_, U256>("balanceOf", (contract_address,), None)?.call(),
)?;

Describe alternatives you've considered
Explicit multicall batching is the main alternative

Additional context
Idea came out of a convo in foundry support telegram: https://t.me/foundry_support/40543