Selfhosted

Sure :)

I knew about bit rot but thought the only solution was something like a zfs pool.

Right. There are other ways of doing this but a checksumming filesystem such as ZFS, btrfs (or bcachefs if you're feeling adventurous) are the best way to do that generically and can also be used in combination with other methods.

What you generally need in order to detect corruption on ab abstract level is some sort of "integrity record" which can determine whether some set of data is in an expected state or an unexpected state. The difficulty here is to keep that record up to date with the actually expected changes to the data.
The filesystem sits at a very good place to implement this because it handles all such "expected changes" as executing those on behalf of the running processes is its purpose.

Filesystems like ZFS and btrfs implement this integrity record in the form of hashes of smaller portions of each file's data ("extents"). The hash for each extent is stored in the filesystem metadata. When any part of a file is read, the extents that make up that part of the file are each hashed and the results are compared with the hashes stored in the metadata. If the hash is the same, all is good and the read succeeds but if it doesn't match, the read fails and the application reading that portion of the file gets an IO error that it needs to handle.

Note how there was never any second disk involved in this. You can do all of this on a single disk.

Now to your next question:

How do I go about manually detecting bit rot?

In order to detect whether any given file is corrupted, you simply read back that file's content. If you get an error due to a hash mismatch, it's bad, if you don't, it's good. It's quite simple really.

You can then simply expand that process to all the files in your filesystem to see whether any of them have gotten corrupted. You could do this manually by just reading every file in your filesystem once and reporting errors but those filesystems usually provide a ready-made tool for that with tighter integrations in the filesystem code. The conventional name for this process is to "scrub".

How do I go about manually detecting bit rot? Assuming I had perfect backups to replace the rotted files.

You let the filesystem-specific scrub run and it will report every file that contains corrupted data.

Now that you know which files are corrupted, you simply replace those files from your backup.

Done; no more corrupted files.

Is a zfs pool really that inefficient space wise?

Not a ZFS pool per-se but redundant RAID in general. And by "incredibly costly" I mean costly for the purpose of immediately restoring data rather than doing it manually.

There actually are use-cases for automatic immediate repair but, in a home lab setting, it's usually totally acceptable for e.g. a service to be down for a few hours until you e.g. get back from work to restore some file from backup.

It should also be noted that corruption is exceedingly rare. You will encounter it at some point which is why you should protect yourself against it but it's not like this will happen every few months; this will happen closer to on the order of every few decades.

To answer your original question directly: No, ZFS pools themselves are not inefficient as they can also be used on a single disk or in a non-redundant striping manner (similar to RAID0). They're just the abstraction layer at which you have the choice of whether to make use of redundancy or not and it's redundancy that can be wasteful depending on your purpose.