RCS should work for you. I used it in the past. But, as you noticed, it's a rather primitive tool set.
That can be mitigate a bit with some custom scripting, which is what I did.
CVS, in fact, started essentially as a scripting layer on top of RCS.
I ended up having a script that worked on a single directory. As all code at the time was that way, this wasn't a big deal.
Today, we'd have a large source tree representing everything. Back then, I had several modules of source code, each in their own directory (mind, these were essentially stand alone modules with little dependency on each other), and within each directory was an RCS directory (I forget what the name was, for some reason something with ",v" comes to mind, or .rcs) that managed the source code. Actually I think it was a .rcs directory, and files were stored in a ,v file. So hello.c was hello.c,v -- something like that.
Then I had scripts that would "check in" and "check out" "everything". By everything, I mean my source code and build files. It wasn't so much "check in *" but more "check in Makefile, *.this, *.that". Then there was similar some introspection in to the RCS dir as to what to check out.
My use case was mostly as a versioned back up. We didn't do things like merges and branching and all that, RCS is really just a primitive versioned file system like construct.
When I had to recover things, it was all done by hand, cherry picking files, and what not.
The only concern is I can't say if the DOS .BAT files are robust enough to do everything that needs to be done. It's been some time (decades!) since I've done this, and it was on a UNIX system. If not, you might need to write some simple wrappers in Pascal or C.
But it was possible, it was workable, and helped save my bacon more than once.
I can't contrast RCS and SCCS, it just seemed at the time that the consensus was RCS was better than SCCS, so that's what I used. It was certainly newer.
I should clarify RCS's behavior (yes, it's coming back to me now...).
As I recall, what RCS did is when you checked something in, it changed the files to "read only", when you check it out, it made them writable. This is in contrast to SVN and GIT which don't (at least by default afaik) do this. But DOS doesn't really have this permissions capability, but I'm not sure if this will be a real issue or not. I don't recall RCS deleting the files on check in, it simply locked them.
RCS may have too may unix-isms in it to really work well with DOS. You'd have to try it and see. But the takeaway from my experience was that it was a usable toolset with a little bit of scripting to make the day to day work well, and perhaps worth experimenting with to see if you can get it work for you. But go in with the expectations of what it really is, basically a versioned file system more so than a complete source code control solution.