Improved stack implementation using a linked list

First observation: your copy constructor and copy assignment create a stack with the items in the reverse order!.

I would use unique_ptr to manage Node lifetimes, one caveat here is performance may be slightly suboptimal on Stack destruction due to the recursive destructor calls. I'd also make Node a private nested struct in Stack since it's an implementation detail. Since t is a sink parameter to the Node constructor you could take it by value and std::move it into place but since you're the only one using the Node constructor you can save a possible extra move by making the parameter T&& t.

If you use unique_ptr to manage Node lifetimes and C++11 member initialization for n you can make your default constructor = default.

Stack::size() should return the same type as your n member, size_t, rather than int. With C++14 you can just use auto return type deduction to avoid the risk of this mistake.

Stack::push() should take its argument by value for the same reason as the Node construtor, it's a sink argument. In this case you could avoid a possible extra move by providing both push(const T&) and push(T&&) overloads but taking by value is simpler.

I'd call Stack::peek() Stack::top() for consistency with std::stack. It should also return a reference rather than by value. This is both for efficiency (no copies of the item) and also avoids the possibility of top() throwing an exception (T's copy constructor might throw an exception in general).

If you use unique_ptr to manage Node lifetimes you don't need an explicit destructor, the default destructor will be correct. The default move constructor and move assignment can also be used, although you must explicitly request them. Copy assignment can be implemented using 'copy and swap'.

I wouldn't throw exceptions on a pop() or top() on an empty stack. I think it's more idiomatic C++ for this to be undefined (as it is for std::stack) but I can see a case for your choice.

Here's how I might implement it:

template <typename T>
class Stack {
    struct Node {
        T item;
        std::unique_ptr<Node> next;
        Node(T&& t, std::unique_ptr<Node>&& tail) : item{std::move(t)}, next{std::move(tail)} {}
    };

public:
    Stack() = default;
    Stack(const Stack&);
    Stack(Stack&& x) = default;
    Stack& operator=(const Stack& x) {
        Stack temp{x};
        std::swap(*this, temp);
        return *this;
    }
    Stack& operator=(Stack&&) = default;

    auto size() const noexcept { return n; }
    bool empty() const noexcept { return n == 0; }

    void push(T t) {
        head = std::make_unique<Node>(std::move(t), std::move(head));
        ++n;
    }
    void pop() noexcept {
        head = std::move(head->next);
        --n;
    }

    T& top() noexcept { return head->item; }
    const T& top() const noexcept { return head->item; }

private:
    std::unique_ptr<Node> head;
    std::size_t n{};
};

template <typename T>
Stack<T>::Stack(const Stack& s) {
    Stack<T> temp;
    auto it = s.head.get();
    while (it) {
        temp.push(it->item);
        it = it->next.get();
    }
    while (!temp.empty()) {
        push(std::move(temp.top()));
        temp.pop();
    }
}

You could make Node<T> an inner struct of Stack. That would be better to avoid having a Node type visible in the global namespace which is not used elsewhere. If you make it a nested type, it no longer needs to be a template, because it will inherit type T from Stack:

template<class T>
class Stack {
public:

    ....

private:

    struct Node {
        T item;
        Node* next;
        Node(const T& t, Node* link) :item{t}, next{link} { }
    };
};

Some spacing between the functions in the declaration wouldn't harm. It would be nicer to give constructor and operators a little more visibility:

Stack() : first{nullptr}, n{0} {}
Stack(const Stack&);
Stack(Stack&&);

Stack& operator=(const Stack&);
Stack& operator=(Stack&&);

void push(const T&);
void pop();
T peek() const;

int size() const { return n; }
bool empty() const { return n == 0; }

~Stack() {
    while (!empty()) {
        pop();
    }
}

Stack::size() should return a size_t, which is an unsigned integral type. Not a signed int:

std::size_t size() const { return n; }

The assignment operator is appending to the current stack:

template<class T>
Stack<T>& Stack<T>::operator=(const Stack& s) {
    for (auto t = s.first; t != nullptr; t = t->next) {
        push(t->item);
    }
    return *this;
}

Since you didn't clear this stack first, if it has any current data, that data will remain and s will be appended to it. Was this the intention?

Also, the order of the elements will be reversed from the source stack in both the copy constructor and assignment operator.

Your move assignment operator leaks memory!

template<class T>
Stack<T>& Stack<T>::operator=(Stack&& s) {
    first = s.first;
    n = s.n;
    s.first = nullptr;
    s.n = 0;
    return *this;
}

Once again, if this stack is not empty, its contents are lost into the void once you do this:

first = s.first;
n = s.n;

You need to first dispose the current stack before taking ownership of s.