Inconsistent behavior of std::common_reference_with on tuples. Which is correct?

Background:

I’m trying to port a library to compile on MSVC.
That library stores data in a tuple of vectors (std::tuple<std::vector<Ts>...>), and uses a custom iterator to iterate over all vectors simultaneously (similar to what a zip_iterator does).

The iterator defines types that look like this (assuming Ts... -> <int, int>) :

`value_type` is `std::tuple<int, int>`  
`reference`  is `std::tuple<int&, int&>`

The problem is that on latest MSVC (v. 19.35), this iterator does not satisfy the concept of std::input_iterator, while it does satisfy it on gcc/clang.

On further investigation, i found the failure to be due to inconsistent behaviour of the std::common_reference concept on tuples.

Issue:

The following static_assert fails on MSVC, while it doesn’t fail on gcc/clang

using T = std::tuple<int, int>&;
using U = std::tuple<int&, int&>;
static_assert(std::common_reference_with<T, U>, "failed common_reference_with");

Here it is on Godbolt (with an iterator example as well)

Question:

Is a type like std::tuple<int, int>& supposed to have a "common_reference_with" std::tuple<int&, int&> ? MSVC says no, gcc says yes.
Which of the two behaviours should be expected according to the standard in C++20 and forward?

Is there any easy way to make this iterator succeed the iterator concept checks on MSVC (ie, force the two types to have a common reference)?

I also found some great answers by Eric Niebler, on std::common_reference (SO) and on proxy iterators (on his blog).

However, it’s not clear to me what is supposed to happen in C++20 and later.