Как передается значение в функцию и почему после перемещения знач. остается?

void F(std::string &&s) {
    std::cout << s;
}
int main() {
    std::string s = "smth";
    F(std::move(s));           //std::move(_Ty&& _Arg)
    std::cout << s;
        return 0;
}
/*
OUTPUT:
smthsmth
*/

//~~~~~~~~~~std::remove_reference
template<typename T>
struct remove_ref{
    using type = T;
};
template<typename T>
struct remove_ref<T&> {
    using type = T;
};
template<typename T>
struct remove_ref<T&&> {
    using type = T;
};
 
//~~~~~~~~~~std::move
template<typename T>
typename remove_ref<T>::type&& mv(T && arg) {
    return (static_cast<typename remove_ref<T>::type&&>(arg));
}
 
//~~~~~~~~~~user's data type
class Car {
private:
public:
    int amow;
    Car() : amow(4) {};
    Car(int a) : amow(a) {}
    Car(const Car &c) {
        amow = mv(c.amow);
    }
    Car& operator=(const Car& c) {
        amow = mv(c.amow);
        return *this;
    }
    Car(const Car&& c) {
        std::cout << &c << "\n";
        amow = mv(c.amow);
    }
    ~Car() {}
};
 
//~~~~~~~~~~swap c++14
template<class T>
void swap(T& a, T& b)
{
    T tmp(mv(a));
/*после перемещения знач. "a" остаются(ну в принципе и логично, т.к. в функции mv(std::move) просто приведение типа)*/
    a = mv(b);
    b = mv(tmp);
}
 
int main() {
    Car a = 2;          //create an object
    Car b = 7;          //create an object
 
    swap(a, b);
    std::cout << a.amow << " " << b.amow << "\n";
        return 0;
}

// есть некий класс dummy и у него есть поле в виде указателя на некие данные
// , а это его констркутор перемещения
dummy(dummy&& other) {
    this->ptr = other.ptr; // ptr - тот самый указатель и что мы здесь делаем? 
                           // Просто его воруем, other'у свои данные уже не нужны.
    other.ptr = nullptr;   // Обнуляем.
}