Actually, I just remembered - I recently found a much better and more robust way of doing the same as described above using lock-files. This sidesteps much of the quirky behavior and limitations that may follow from using window titles (like when you run windowless scripts, on SYSTEM-level ect.) should also just be much more solid as a true pseudo-mutex (much less vulnerable to timing problems).
here is an example of how to use a lock-file as a mutex:
:: Note - this extra call is to avoid a bug with %~f0 when the script
:: is executed with quotes around the script name.
:: The CALL will fail if another process already has a write lock on the script
call :main 9>>"%~f0"
:: Body of your script goes here. Only one process can ever get here
:: at a time. The lock will be released upon return from this routine,
:: or when the script terminates for any reason
So the way this would be relevant to your problem is that you could use a very simple wrapper-script to launch the mount script. Before it does, the wrapper script locks down exclusive access to some some arbitrary file (the scripts themselves may be those files themselves in some cases - for example the wrapper-script could be used here maybe).
Then you still launch mount as
start /b rclone mount ...
[a loop goes here]
Just as the example above...
But the loop at the end of the mount-script - instead of continually checking for windows with a certain name like in previous example would loop and continually try to get write-lock on that same file as the wrapper did (and fail until the wrapper releases it). This is very robust because the OS assures that no matter what causes the wrapper script to stop running, the write-lock is released. Feel free to brutally murderize it by any means you want
The OS will also never allow 2 thinks to write-lock the same file ever - so it's a garantueed mutex by Microsoft, not some hacky solution (like above) that might fail in rare edge-cases and be vulnerable to strange timings.
So to end the mount gracefully - you'd hard-kill the wrapper-script by any means you want. The OS then will automatically release the write-lock. The loop in the mount-script then can get past the hurdle and hit the "exit" at the end which then makes it soft-exit gracefully.
Disclaimer: The write-lock mutex example code is not mine. I shamelessly stole it from stackoverflow.
Again - if you are interested in something like this I can add more detail - but if you want to go the ideal route of integrating this into rclone (which I by all means encourage you to do since we can all benefit from it) then I won't waste time doing it in advance
(Now if you'll excuse me this just reminded me I have to go re-work my own scripts to use this more robust mutex lock on my existing multithreaded functions =P )