(I must emphasise, this is wild speculation. I have not seriously looked into this, and for all I know expert 3BLDers have and got to a different conclusion.)
Whether the buffers are adjacent matters only when there is parity: if there's no parity, then solving the edges and solving the corners are basically independent, so who cares if your buffer choices are adjacent or not.
There are pretty much seven ways of dealing with parity (assuming edge-corner execution order; if you use the other order, then just swap the words "edge" and "corner"):
1. swap buffer edge with last target and swap two other edges, then do the first corner target while swapping those two edges back (as in OP; neither of those two edges is the buffer or last target)
2. 3-cycle the buffer edge with the last target and something else, then do the first corner target while swapping the two unsolved edges back (as in OP; one of those two edges is the buffer)
3. directly solve the edges into a state with two edges swapped (by swapping in memo), then do the first corner target while swapping the two unsolved edges (as in OP)
1'. same as 1, but with the last corner target (solve the earlier corner targets with 3-cycles or whatever first)
2'. same as 2, but with the last corner target
3'. same as 3, but with the last corner target
4. swap buffer edge with last target and swap buffer corner with first target
5. (doing parity at the end) swap buffer edge with last target and swap buffer corner with last target
6. (doing parity at the start) swap buffer edge with first target and swap buffer corner with first target
7. quarter turn premove
7'. quarter turn start
(This does not account for flipped edges, cycle breaks, floating buffer, etc., for which I assume there are even more ways of dealing with parity. Idk, not an expert, don't look at me.)
~ executive summary ~
method 1: prefer non-adjacent buffer (but also prefer method 2 instead)
method 2: prefer adjacent buffer
methods 3, 7: adjacency irrelevant
methods 4, 5, 6: adjacency irrelevant, except to alg learning difficulty, maybe?
As far as I know, nobody seriously does #6 or #7. #1', #2' and #3' are minor variations of #1, #2 and #3 respectively, so I won't treat them differently.
#4, #5 and #6 all require learning a set of 21×22 = 462 parity algs (but presumably a fair chunk of these are easy setups into others). As far as I can tell, whether you use adjacent buffers or not matters little, because most of the algs are weird regardless. However, if you do use adjacent buffers, then it should be easier to find one-move setups between the different parity cases, since that gives you more choices of that one move to use as the setup (e.g. there are 7 choices of layers to turn that fix UF&URF, versus 5 choices that fix UF&ULB), so this might make learning the algs easier.
#1 and #2 are inferior to #3 in that they require an extra alg on average (and 2e2e algs for #1 are slightly worse than 3e algs for #2), but they do have the advantage that you can use the same order for memo and execution (supposedly, this is better for MBLD), whereas the memo-swap used in #3 really only works with ceec order. All three of these need only 21 parity algs, and in the most basic version, you'd just use setups to Y perms.
In #3, whether the buffers are adjacent turns out to be completely irrelevant, since the memo swap works regardless of whether it involves your edge buffer. This leaves only #1 and #2 left to consider.
Also, I say "as in OP", but really, nobody's forcing you to use UB-UR edge swap for OP corners: you could, in theory, use a variant of OP where you swap two other edges. So, which two? Up to AUF, there are only four different choices of edge swaps in the top layer:
- UF-UR (adjacent)
- UF-RU (adjacent flipped)
- UF-UB (opposite)
- UF-BU (opposite flipped)
And there are quite a few more if you include non-top-layer swaps; I know nothing about advanced BLD techniques but I do know a bunch of last layer algs, so let's just suppose I can extrapolate my last layer knowledge and disregard those. And for these swaps, there's still the question of which corner piece is the buffer. By choosing something like UF-UR with URF buffer (so the corner buffer is adjacent to both edges), this maximises the number of free layers, which increases the number of useful 1-move/2-move setups. It also turns out that, at least among the last layer algs I know, UF-UR-URF has nicer algs on average than the others. UF-UB-anything is mostly very bad, for example (think of N perms and F perms); UF-BU-anything seems to be about as bad (possibly worse); UF-UR-UFL shares some cases with UF-UR-URF, but the cases that aren't shared are a bit worse. (I know next to nothing about the UF-RU 22LLs.)
So let's say we're using UF-UR swap with URF buffer. If we're using parity method #1, this means our buffer should be something other than UF or UR, i.e. choosing a buffer that is not adjacent. If we're using parity method #2, this means our buffer should be UF or UR, i.e. one of the edges adjacent to the corner buffer. Since method #2 is better than #1 (uses a 3e alg rather than 2e2e), it follows that one should prefer adjacent buffers.
However, all that said, if you use 3-style, whether the buffers are adjacent or not affects only half an alg out of the 10-ish you need to solve the whole cube, which also means that you'll get pretty close to the optimal choice of buffers just by selecting them for having better 3-cycles without caring about parity. In that case, since UF and URF are generally agreed to have the best 3-cycle algs, you should choose those for that reason, and not because they're adjacent.
