How to correctly use RSA for digital signature with hashing?
You're missing two things:

First off, we don't try to retrieve the message from the hash; as you correctly point out, that's impossible.  Instead, what we do is (using your notation):


Accept $[m,s]$
Take public key $[e,n]$
Retrieve the hashed message: $m'_{hashed} = P_a(s) = s^e \bmod(n)$
Generate the hash of the message being verified $m_{hashed} = Hash(m)$
Check authenticity of signature and message immutability by comparing $m_{hashed}$ and $m'_{hashed}$


If we assume that the hash function is collision resistant, that is, it is infeasible to find two distinct messages $M_a, M_b$ with $Hash(M_a) = Hash(M_b)$, then if $m_{hashed} = m'_{hashed}$, then either we've demonstrated a hash collision (which we assume is difficult), or $m = m'$.

The other thing you are missing is padding.  We (should) never take output of a hash function, interpret it as an integer, and hand it off to the RSA function; if we do that, then an attacker could potentially take advantage of the homomorphic property of RSA, namely, $a^e \bmod n \times b^e \bmod n \equiv (ab)^e \bmod n$, look through a pile of signatures for hashes that happen to have common factors, and cobble together a signature to a new message (whose hash is made up of those common factors).  Instead, we always apply a padding function to the hash output to turn it into a large (nearly as large as $n$) integer, and then apply the RSA function to that.

There are a number of padding methods known that are believed to be secure, including PSS and RSASSA-PKCS1-v1_5; the reference I gave you short get you started.