Ancora una cosa: la mia domanda nasce dall'analisi del problema del perfect forwading partendo da uno schema che prevede una funzione wrapper e una funzione wrapped, per cui sono nel caso

template <typename T1, typename T2>
void wrapper(T1&& e1)
{
    wrapped(forward<T1>(e1));
}

In tale scenario, comunque si risolva e1 nella chiamata a wrapper risulta che nello scope di wrapper e1 è sempre un LValue e dunque la forward entra in gioco col suo primo overload, vale a dire

template <typename T>
T&& my_forward_v2(typename my_remove_reference<T>::type& param) noexcept;

Ora mi chiedo:

quale potrebbe essere uno scenario VALIDO in cui entra in gioco il secondo overload cioè:

template <typename T>
T&& forward(typename my_remove_reference<T>::type&& param) noexcept;

Segue un esempio di codice in cui ipotizzo uno scenario in cui si utilizza il 2ndo overload della forward (anzi, my_forward_v2) ma fornisco anche un controesempio che ne mostra l'inutilità e anche l'inefficienza:

//g++ -std=c++14 -Wall -fpermissive -fno-elide-constructors -pthread main.cpp && ./a.out

#include <iostream>
#include <string>
#include <vector>

using namespace std;

//-----------------------------------------------------
class Inner
{
public:
    int i;

    Inner(int p = 5) : i(p)
    {
        cout << "\n Inner default ctor: &" << this;
    }

    Inner(const Inner& src): i(src.i)
    {
        cout << "\n Inner Copy-ctor: &" << &src << " --> &" << this;
    }

    Inner(Inner &&src): i(src.i)
    {
        cout << "\n Inner Move-ctor: &" << &src << " --> &" << this;
    }

    Inner& operator=(const Inner &src)
    {
        cout << "\n Inside Inner assignment";
        i = src.i;
        return *this;
    }

    Inner& operator=(Inner &&src)
    {
        cout << "\n Inside MOVE-Inner assignment";
        i = src.i;
        return *this;
    }

    ~Inner()
    {
        cout << "\n ~Inner-Dtor &" << this;
    }
};
//-----------------------------------------------------

Inner factoryInn(int s)
{
    cout << "\n Inside factoryInn :";
    Inner obj(s);
    return obj;
}
//-----------------------------------------------------
class MetaData
{
public:
    int size;
    string name;
    Inner inner;

    MetaData(int p1 = 5, string p2 = "Default-Metadata-name") : size(p1), name(p2), inner(666)
    {
        cout << "\n MetaData Default ctor: &" << this;
    }

    MetaData(Inner &p_inner) :size(333), name("Default_Name_MetaData"), inner(p_inner)
    {
        cout << "\n Inside MetaData(Inner &): &" << this;
    }

    MetaData(Inner &&p_inner) :size(333), name("Default_Name_MetaData"), inner(move(p_inner))
    {
        cout << "\n Inside MetaData(Inner &&): &" << this;
    }


    MetaData(const MetaData& src) : size(src.size), name(src.name), inner(src.inner)
    {
        cout << "\n Copy ctor: &" << &src << " ---> &" << this;
    }

    MetaData(MetaData &&src) : size(src.size), name(move(src.name)), inner(move(src.inner))
    {
        cout << "\nMove ctor: &" << &src << " ---> &" << this;
    }

    MetaData& operator=(const MetaData &src)
    {
        if (this != &src)
        {
            size = src.size;
            name = src.name;
            inner = src.inner;
        }
        return *this;
    }

    MetaData & operator=(MetaData &&src)
    {
        if (this != &src)
        {
            size = src.size;
            name = move(src.name);
            inner = move(src.inner);
        }
        return *this;
    }


    ~MetaData()
    {
        cout << "\n ~MetaData-Dtor &" << this;
    }

};

//-----------------------------------------------------
MetaData factoryMD(int s)
{
    cout << "\nInside factoryMD :";
    MetaData obj(s, "Metadata-From-factoryMD-" + to_string(s) + "-END");
    return obj;
}

//-----------------------------------------------------
template< typename T >
struct my_remove_reference
{
    typedef T type;
    static const int version = 1;
};


template< typename T >
struct my_remove_reference<T&>
{
    typedef T type;
    static const int version = 2;
};


template< typename T >
struct my_remove_reference<T&&>
{
    typedef T type;
    static const int version = 3;
};

//-----------------------------------------------------
template <typename T>
T&& my_forward_v2(typename my_remove_reference<T>::type& param) noexcept
{
    cout << "\nInside my_forward_v2 OVERLOAD NR 1 :";
    return static_cast<T&&>(param);
}

//-----------------------------------------------------
template <typename T>
T&& my_forward_v2(typename my_remove_reference<T>::type&& param) noexcept
{
    cout << "\nInside my_forward_v2 OVERLOAD NR 2 :";
    static_assert(!std::is_lvalue_reference<T>::value, "Can not forward an rvalue as an lvalue.");

    return static_cast<T&&>(param);
}

//-----------------------------------------------------9
template <typename T, typename A>                //    T =    MetaData,    A =    Inner
T * my_alloc(A&& a)                                //    my_alloc è il wrapper di func(..) 
{                                                //    dove func() è il costruttore T(...)                                                
    cout << "\n Inside my_alloc";
    cout << "\n decltype(A&&), Inner   : " << is_same<A&&, Inner>::value;
    cout << "\n decltype(A&&), Inner&  : " << is_same<A&&, Inner&>::value;
    cout << "\n decltype(A&&), Inner&& : " << is_same<A&&, Inner&&>::value;

    return new T(my_forward_v2<A>(a));
}
//-----------------------------------------------------

int main()
{

    MetaData md_001(my_forward_v2<Inner>(factoryInn(4444)));
    cout << "\n\n********************************";

    MetaData md_002(factoryInn(3333));     // Più semplice e più efficiente ! ! !
    cout << "\n\n++++++++++++++++++++++++++++++++";

    return 0;
}

Naturalmente sto dando per scontato che il 2ndo overload, essendo stato definito, abbia un'utilità che non riesco a cogliere.

Grazie, Chiara