Are any of these implemented in EOF, i.e. callable, like ext* calls?

They are not callable from yul level, but legacy jump and jumpi are reserved but also not callable from yul. So I assumed they should be reserved also.

You could use hasOpcode() to avoid repeating these:

EVMVersion::prague().hasOpcode(_instr, 1) && !EVMVersion::prague().hasOpcode(_instr, std::nullopt)

With an extra assert that EOF version is 1 and EVM version is <= Prague because this will need to be adjusted once new versions are out (if they and add/remove instructions).

BTW, validateInstructions() should have such an assert too, because it hard-coded EOF version to 1 and we can easily forget to update it once we have EOF v2.

Just to make it clear.
Function eofIdentifiersException returns true if identifier based on an instruction should not be reserved. false otherwise. So in case when _eofVersion == 1 this function should always return false and in case when _eofVersion == std::nullopt we should omit reserving EOF specific identifiers related to EOF instructions.
Right? I think it would be better to change the assumption of these functions to return false on "do not reserve" and true otherwise. It's very confusing now.

The functions say whether to apply the exception from the rule (which is to treat instruction names as reserved identifiers). The current return values do make sense to me with that naming.

I guess we could rename them if that's not clear. I'd actually consolidate them all into one check and call it something like validAsIdentifierForBackwardsCompatibility() or validAsIdentifierOnCurrentEVM(). We could then make the older checks more general as well, by just checking if it's an instruction that exists on current EVM but not on the latest one.

If you want to do that, I'd do it as a separate refactor PR though.