phils is correct; if you use
letter for your personal customizations then you're not supposed to have to worry about conflicts with the key bindings from a mode.
As for actually enumerating all possible keymaps to check if they would define the same shortcut… that's a bit difficult. As far as I know, there's no global list of all keymaps. There's no global list of all variables that are defined, so you can't enumerate all variables and check for keymaps either. In fact, there's no requirement that a keymap has to be stored in a variable at all; it can be created on the fly for transient use. Finally, most keymaps aren't even in memory at all until they are first used. All that Emacs knows at startup is that some symbols are defined but not yet loaded, and what file to load them from.
I wouldn't say that it's completely impossible, however.
With sufficient determination, you could take advantage of the autoloader system to get a list of variables that hold keymaps. Each variable that is to be autoloaded has to be declared as such by calling the
autoload function (Use
C-h f autoload to see the documentation). You could advise the
autoload function and save a list of keymaps to a variable of your choosing. Something like this:
(define-advice autoload (:before (function file &optional docstring interactive type) stash-keymap-names)
"stashes the names of symbols holding autoloaded keymaps in *my-list-of-keymaps*"
(when (eq type 'keymap)
(add-to-list '*my-list-of-keymaps* function)))
However, there is another wrinkle: the autoload declarations are not read in by Emacs on every startup. That would be too slow. Instead, the list of autoload declarations is created during the Emacs build process. This list is then read in once by Emacs (along with a number of other lisp files). The running Emacs then dumps it's own memory out into a new Emacs executable, so that everything created by those lisp files that it read in is automatically available the next time Emacs is run, without having to load any lisp files at all.
So what you need to do is to define this advice very early on in the boostrap process, before it reads the autoload declarations. The variable you're stashing keymap names into will then be baked into the resulting Emacs executable. You can then run the new executable and use the list of symbols to enumerate most of the keymaps that Emacs will ever use.