As pointed in [comment][1]

1. _"encrypt" with sender's private key_ is improper terminology; the proper term is _sign_. I took the liberty to fix that common error in the question. If we used anything else than trapdoor-permutation-based public-key cryptography (RSA, Rabin for the most), _"encrypt" with sender's private key_ would be plain unintelligible.
2. It's assumed $n_r>n_s$ so that $c_1<n_r$, which is necessary to get $\widetilde{c_1}=c_1$. Thus the technique won't "work" with 100% reliability in both directions unless we take some precaution.

Also, the issue of padding is ignored. And more broadly the security goals are not stated.

Issue 2 can be solved in a number of ways:
- The best is to use separate keys for signature and encryption, with a maximum $n$ for the first applied (signature in the question) lower than the minimum for the second. That abides to the time-proven security design principle: _one usage, one key_. It also avoids the embarrassment of ending up with $c_2=m$ when the sender is the receiver, something an adversary might induce.
- Another option is to force all $n$ to share the same bit size and many high order bits (say 512, which become a fixed public arbitrary constant). That insures $c_1<n_r$ with overwhelming probability. It does not solve the send-to-self issue.
- Yet another is to require all $n$ to have the same bit size, restrict to (say) even $m$, and use $c_1\gets \min\bigl((m^{d_s}\bmod n_s),(-m^{d_s}\bmod n_s)\bigr)$. On decryption, we'll have either $m=\widetilde{c_2}$ or $m=n-\widetilde{c_2}$, and the parity of $m$ allows to determine which. It does not solve the send-to-self issue.
- A variant of the above forces $m<\min(n)/2$, which also allows recovery of $m$.

Another issue is that that both RSA encryption and signing require redundancy for security; plus encryption requires random padding (or non-guessable plaintext) in what's processed with textbook RSA encryption. That can be solved by:
- pad $m$ with randomness and redundancy
- sign with textbook RSA using private key $(n_s,e_s)$ [in it's instance for signature, if distinct from encryption]
- encrypt with textbook RSA using public key $(n_r,e_r)$ [in it's instance for encryption].

Proper checking of the redundancy on decryption insures integrity and protects against decryption padding oracle attacks.

Encrypt-then-Sign works as well, and is used in the [RSA-based authentication protocol][2]¹ between (pan-)European Digital Tachograph and it's Smart Cards. It uses the $\min$ and even padded message trick. A modern variant would use [RSAES-OAEP][3] padding and the $m<\min(n)/2$ trick, or best separate encryption and decryption keys.
___
¹ Designed circa the end of the 20<sup>th</sup> century, I wish I knew exactly by who.

  [1]: https://crypto.stackexchange.com/posts/comments/199064
  [2]: https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:32016R0799&from=EN#page=351
  [3]: https://pkcs1.grieu.fr/#page=16