Компилятор требует, чтобы пользовательский итератор имел целочисленный тип, чтобы он считался прямым итератором

Я пишу итератор для пользовательской коллекции:

template <typename T>
class List
{
public:
    class Iterator
    {

    public:

        using difference_type = T;
        using value_type = T;
        using pointer = const T*;
        using reference = const T&;
        using iterator_category = std::forward_iterator_tag;

        Iterator(T* ptr = nullptr) : _ptr(ptr) {}
        Iterator& operator++() { _ptr++; return *this; }
        Iterator operator++(int) { Iterator retval = *this; ++(*this); return retval; }
        std::strong_ordering operator<=>(Test& other) { return _x <=> other._x; }
        bool operator==(Iterator other) const { return _ptr == other._ptr; }
        bool operator!=(Iterator other) const { return !(_ptr == other._ptr); }
        reference operator*() const { return *_ptr; }
        pointer operator->() const { return _ptr; }
        reference operator=(const T& value) { *_ptr = value; return value; }

    private:
        T* _ptr;

    };

    Iterator begin() { return Iterator(_data); }
    Iterator end() { return Iterator(_data + 4); }

    List() // Generate generic data
    {
        for (int i = 0; i < 5; i++)
        {
            _data[i] = i + 1;
        }
    }

private:
    T _data[5];
};

Это должен быть прямой итератор, но когда я проверяю это с помощью статического утверждения, я могу использовать только экземпляры List<T>, где тип T является целочисленным типом. Ниже приведен пример нецелых типов float и небольшого Test класса. Я также протестировал итератор std::vector<Test> по умолчанию с идентичным статическим утверждением и не получил ошибки.

class Test
{
public:
    Test(int x = 0) : _x(x) {}
    void Increment() { _x++; }
    std::strong_ordering operator<=>(Test& other) { return _x <=> other._x; }
    int operator=(int x) { _x = x; return x; }
    friend std::ostream& operator<<(std::ostream& os, const Test& m) { return os << m._x; };

private:
    int _x;
};

int main()
{
    List<int> container1;
    List<Test> container2;
    List<float> container3;
    std::vector<Test> container4;

    static_assert(std::forward_iterator<decltype(container1.begin())>); // no error
    static_assert(std::forward_iterator<decltype(container2.begin())>); // ERROR
    static_assert(std::forward_iterator<decltype(container3.begin())>); // ERROR
    static_assert(std::forward_iterator<decltype(container4.begin())>); // no error

    // This loop works correctly if the static asserts are commented out
    for (List<int>::Iterator it = container1.begin(); it != container1.end(); it++)
    {
        std::cout << *it << "\n";
    }


    return 0;
}

Я использую стандарт ISO C++20 с компилятором Visual C++. Расширение ошибок дает мне эту трассировку стека ошибок, заканчивающуюся ошибкой «ограничение не было удовлетворено». Ошибка ссылается на эту строку в __msvc_iter_core.hpp:

template <class _Ty>
concept _Integer_like = _Is_nonbool_integral<remove_cv_t<_Ty>> || _Integer_class<_Ty>;

Я не знаю, зачем нужен целочисленный тип. Я не думаю, что класс Test является проблемой, поскольку утверждение работает с векторным итератором, но я не вижу в классе Iterator ничего, что требовало бы, чтобы T было целочисленным. Почему это требование проверяется?