// TEMPLATE FUNCTION forward
template<class _Ty> inline
    _Ty&& forward(typename remove_reference<_Ty>::type& _Arg) // Зачем реализовано именно так?
    {    // forward an lvalue
    return (static_cast<_Ty&&>(_Arg));
    }

template<class _Ty> inline
    _Ty&& forward(typename remove_reference<_Ty>::type&& _Arg) _NOEXCEPT // Зачем реализовано именно так?
    {    // forward anything
    static_assert(!is_lvalue_reference<_Ty>::value, "bad forward call");
    return (static_cast<_Ty&&>(_Arg));
    }

// Здесь со специализациями шаблона, понятно как это работает. Но вот непонятно почему это реализовано именно так?
    // TEMPLATE remove_reference
template<class _Ty>
    struct remove_reference
    {    // remove reference
    typedef _Ty type;
    };

template<class _Ty>
    struct remove_reference<_Ty&>
    {    // remove reference
    typedef _Ty type;
    };

template<class _Ty>
    struct remove_reference<_Ty&&>
    {    // remove rvalue reference
    typedef _Ty type;
    };

    // TEMPLATE FUNCTION forward
template<class _Ty> inline
    _Ty&& forward(typename remove_reference<_Ty>::type _Ty& _Arg) // Почему не так?
    {    // forward an lvalue
    return (static_cast<_Ty&&>(_Arg));
    }

template<class _Ty> inline
    _Ty&& forward(typename remove_reference<_Ty>::type _Ty&& _Arg) _NOEXCEPT // Почему не так?
    {    // forward anything
    static_assert(!is_lvalue_reference<_Ty>::value, "bad forward call");
    return (static_cast<_Ty&&>(_Arg));
    }

ПРИМЕР1 :
template<typename T>
void Test(T&) {}

template<typename T>
void Test(T&&) {}

int main()
{
    X x1;
    Test(x1);
}

template<typename T>
void Test(T&) {}

void TestInt(int &) {}
void TestInt(int &&) {}

int main()
{

    int x1;
    TestInt(x1);
}

typename remove_reference<_Ty>::type

template<typename T>
void test(T&& t) { use(forward<T>(t)); }

template <class T> T&& forward(T& t) noexcept { return static_cast<T&&>(t); }

If you want to dig a little deeper for extra credit, ask yourself this question: why is the remove_reference in the definition of std::forward needed? The answer is, it is not really needed at all. If you use just S& instead of remove_reference<S>::type& in the defintion of std::forward, you can repeat the case distinction above to convince yourself that perfect forwarding still works just fine. However, it works fine only as long as we explicitly specify Arg as the template argument of std::forward. The purpose of the remove_reference in the definition of std::forward is to force us to do so.

#include <iostream>
#include <utility>
class X{};

template<typename T>
void Test(T&) { std::cout<< 1;}

template<typename T>
void Test(T&&) {std::cout<< 2; }

template<typename T>
T&& myForward(T& arg)
{
    return static_cast<T&&>(arg);
}

template<typename T>
void Func(T&& arg)
{
   // Test(std::forward<T>(arg));
   // Test(myForward<T>(arg));     Работают экквивалентно. Выводит 12
   
   // 
   // В этом моменте вывод типов срабатывает немного по-другому. Почему?
   // 
   Test(myForward(arg));     // Выводит 22
}

int main()
{
    X x1;
// lvalue : Expected version: Test(T&) 
    Func(x1);

// rvalue : Expected version: Test(T&&) 
    Func(X());
}

#include <type_traits>
#include <utility>

#define FORWARD(x) \
    std::forward \
    < \
        typename std::conditional \
        < \
            std::is_rvalue_reference<decltype(x)>::value, \
            typename std::remove_reference<decltype(x)>::type, \
            decltype(x) \
        >::type \
    >(x) \
/**/

/*******************************************/

#include <iostream>

struct Foo
{
    Foo() = default;
    Foo(const Foo &)
    {
        std::cout << "copy" << std::endl;
    }
    Foo(Foo &&)
    {
        std::cout << "move" << std::endl;
    }
};

template<typename T>
void test(T &&x)
{
    Foo{std::forward<T>(x)};
    Foo{FORWARD(x)};
    std::cout << std::endl;
}

int main()
{
    Foo x;
    test(x);
    test(std::move(x));
    test(Foo{});
}

copy
copy

move
move

move
move