next-error use cases

[Juri Linkov]

Several bug reports such as bug#20489 and bug#30674 revolve around
the uncertainty caused by unclear requirements for the next-error framework.
It would be helpful to identify possible scenarios to get a clearer picture of
what it's supposed to do.

The cornerstone of the whole feature is the function next-error-find-buffer
that returns a next-error capable buffer that defines next-error-function
to navigate to the next location.

Most fallbacks in next-error-find-buffer are fine in case the first condition
fails, but the main question is about the first condition itself: What is the
best default behavior for it?  What other useful options it should provide?
What context should be used to select the right next-error-function buffer.

There are several alternatives of what buffer with next-error-function
should be selected after running next-error:

1. last next-error-function used anywhere globally
Pros: context-free, thus easier to understand
Cons: not WYSIWYG, i.e. in some cases produces unexpected results:
      for example, after switching to another next-error-function buffer
      will still continue the previous navigation from the hidden buffer
      with last used next-error-function

2. next-error-function found in the current buffer
Cons: unexpected results when navigation visits another buffer with 
next-error-function,
      e.g. when a ChangeLog file is visited by next-error from the *grep* 
buffer,
      the next next-error should continue visiting grep hits, not ChangeLog 
entries.
      (But when a next-error navigation never visited a next-error-function 
buffer, then
      running `next-error' in a next-error-function buffer should use it 
unconditionally,
      e.g. switching to a *compilation* buffer and running next-error should 
use it.)

3. next-error-function that visited the current buffer,
   i.e. buffer-local value of next-error-last-buffer remembers the last used
   next-error-function buffer in each visited buffer, and uses it for the next
   next-error.
Cons: unexpected results when the same buffer is visited in different windows
      from different next-error-function buffers

4. next-error-function that visited the buffer in the selected window
Pros: window-based logic gives more expected results

5. buffer with next-error-function visible in one of adjacent windows on the 
same frame
Pros: WYSIWYG
Cons: ambiguous when there are more than one window with next-error-function on 
the frame

What complicates matter more is that the value of next-error-function might
come from the same buffer where navigation occurs, i.e. unlike these cases
where next-error-function is defined in a special separate buffer:

compilation-next-error-function
xref--next-error-function
occur-next-error
change-log-next-error
diff-next-error

next-error-function can be defined in the same buffer, for example for:

flymake-goto-next-error
flyspell-goto-next-error

where the list of locations comes from the same buffer where next-error
navigates.

So the question is how one buffer can provide many next-error functions
by such different major/minor modes (flymake, flyspell) enabled in it
at the same time?