type dedution and reference collapse in c++ 11(works vc++ 2013)

#include <iostream>
#include <string>
#include <utility>

template<typename T>
struct Ident
{
	static char const* name()
	{
		return "T";
	}
};


template<typename T>
struct Ident<const T>
{
	static char const* name()
	{
		return "T const";
	}
};

template<typename T>
struct Ident<volatile T>
{
	static char const* name()
	{
		return "T volatile";
	}
};

template<typename T>
struct Ident<volatile const T>
{
	static char const* name()
	{
		return "T volatile const";
	}
};

template<typename T>
struct Ident<T&>
{
	static char const* name()
	{
		return "T&";
	}
};

template<typename T>
struct Ident<T const&>
{
	static char const* name()
	{
		return "T const&";
	}
};

template<typename T>
struct Ident<T volatile&>
{
	static char const* name()
	{
		return "T volatile&";
	}
};

template<typename T>
struct Ident<T volatile const&>
{
	static char const* name()
	{
		return "T const volatile &";
	}
};

template<typename T>
struct Ident<T&&>
{
	static char const* name()
	{
		return "T&&";
	}
};

template<typename T>
struct Ident<T const&&>
{
	static char const* name()
	{
		return "T const&&";
	}
};

template<typename T>
struct Ident<T volatile&&>
{
	static char const* name()
	{
		return "T volatile&&";
	}
};

template<typename T>
struct Ident<T volatile const &&>
{
	static char const* name()
	{
		return "T const volatile &&";
	}
};

void bar(std::string&)
{
	std::cout << "void bar(std::string &)" << std::endl;
}

void bar(std::string volatile &)
{
	std::cout << "void bar(std::string volatile&)" << std::endl;
}

void bar(std::string const &)
{
	std::cout << "void bar(std::string const&)" << std::endl;
}

void bar(std::string const volatile &)
{
	std::cout << "void bar(std::string const volatile&)" << std::endl;
}

void bar(std::string &&)
{
	std::cout << "void bar(std::string &&)" << std::endl;
}

//type deduction and then reference colappse
template <typename MyT>
void foo(MyT&& a)
{
	std::cout << "MyT:" << Ident<MyT>::name() << ", MyT&:" << Ident<MyT&>::name() << ", MyT&&:" << Ident<MyT&&>::name() << std::endl;
	//forward argment a with reserved rvalueness/lvalueness, constness, volatileness
	bar(std::forward<MyT>(a));
	//bar(std::move(a));
}


int main()
{

	{
		//rvalue
		foo([]()-> std::string{return "10"; }());
		std::string x = "11";
		//lvalue
		foo(x);
		std::string& y = x;
		//lvalue
		foo(y);
		std::string&& z = "12";
		//lvalue
		foo(z);
	}

	{
	//const rvalue
	foo([]()->std::string const{return "10"; }());
	std::string const x = "11";
	//const lvalue
	foo(x);
	std::string const & y = x;
	//const lvalue
	foo(y);
	std::string const&& z = "12";
	//const lvalue
	foo(z);
}

	{
		//volatile rvalue
		foo([]()->std::string volatile{return "10"; }());
		std::string volatile x = "11";
		//volatile 	lvalue
		foo(x);
		std::string volatile & y = x;
		//volatile lvalue
		foo(y);
		std::string volatile && z = "12";
		//volatile lvalue
		foo(z);
	}

	{
		//const volatile rvalue
		foo([]()->std::string volatile const {return "10"; }());
		//const volatile lvalue
		std::string volatile  const x = "11";
		//const volatile lvalue
		foo(x);
		std::string volatile const & y = x;
		//const volatile lvalue
		foo(y);
		std::string volatile const && z = "12";
		//const volatile lvalue
		foo(z);
	}
	return 0;
}