A quanto pare l'implementazione di di std::function in G++4.6 è buggata. Avevo letto qualcosa in proposito e probabilmente l'hanno sistemata nella versione 4.7.
E io davo per scontato che tu usassi la 4.7 (del resto non avevi indicato la versione del compilatore).

Lo standard C++11 prevede la sintassi funzione() = delete per imporre al compilatore il divieto di usare una funzione; questò è utile per disabilitare il costruttore di copia e l'operatore di assegnamento senza renderli per forza privati.
Dato il bug su riportato, però, occorre che almeno il costruttore di copia sia implementato.
Le funzioni con il doppio && permettono di accedere ai parametri di rhs e poterli modificare. In questo modo se una classe è composta da dati a loro volta spostabili il tempo, di spostamento dati è minore del tempo necessario a copiarli.
In questo specifico caso non è che cambi molto, ma per altri tipi di classi la copia di dati è molto più onerosa rispetto al solo spostarli.

Per fortuna però il bug su riportato è solo per std::function (all'interno del costruttore di std::thread), pertanto la classe Socket modificata è comunque corretta e potenzialmente usabile tramite move().

Ad esempio se tu volessi invocare Server::serviceRoutine() senza passare dai thread, rimane valida la sintassi
codice:
serviceRoutine(move(new_sock));
e non valida la sintassi
codice:
serviceRoutine(new_sock); // errore no costruttore copia.
Dato che implementare il costruttore di copia nella classe Socket comporta riscrivere alcune funzioni, io aggiro il problema e ti suggerisco di modificare Run() e ServiceRoutine() così:
codice:
void Server::Run()
{
    Socket serversock;
    std::shared_ptr<Socket> new_sock = std::make_shared<Socket>();
    ...

    while(!thread_stop)
    {
        serversock.accept(*new_sock);
        if (new_sock->is_valid())
        {
            cout<<"Ricevuta connessione\n";
            thread_serventi[n_thread] = move(
                thread(
                    &Server::serviceRoutine,this,move(new_sock)
                )
            );
            n_thread++;
        }
    }
    cout<<"Fermato thread principale del server\n";
    return;

}

void Server::serviceRoutine(std::shared_ptr<Socket> sock) {
    // nessuna altra variazione
    ...
}
In pratica new_sock diventa un puntatore intelligente che mantiene in vita i dati di Socket e si occupa da solo di chiudere la connessione e liberare la memoria.
In linea teorica andrebbe bene anche un puntatore normale, ma sarebbe solo un complicarsi la vita per niente.

dove hai imparato tutte ste cose?
Blog, articoli, varie ed eventuali. In questo periodo stanno uscendo alcuni libri aggiornati al nuovo standard (tra cui quello di Stroustroup), però non ho seguito un percorso lineare.
Ti posso consigliare alcune voci base (in English of course):

Una panoramica generale
http://en.wikipedia.org/wiki/C%2B%2B0x

Un riferimento aggiornato alle novità:
http://en.cppreference.com/w/

La pagina che riporta i progressi dei vari compilatori riguardo lo standard in generale.
http://wiki.apache.org/stdcxx/C++0xCompilerSupport