Take note of the examples:

>     :execute "buffer" nextbuf
>     :execute "normal" count .. "w"

What it's indirectly saying is, to avoid a space, use `..` instead of no operator at all. When there's no operator at all, each string or potentially variable is considered a separate argument.

First of all, I don't know if it's a typo on your end or if that's the actual result you're getting, but `:echo 'a' 'b'` for me (Vim 8.2 1-3013) echos `a b`. The point behind using the `..` operator is to do string concatenation instead of applying "simulated" varargs that have a space appended between each argument. In a manner of speaking, the way `echo` works can be compared to Python's `print()` function: If you `print('a', 'b')`, you get `a b`, but if you `print(a + b)`. The point is, this *demonstrates* that `.` and `..` do the same thing in this specific context: it does string concatenation instead of passing "multiple arguments" to `echo`. Demonstration aside, let's look at some actual evidence of that from the help.


The page of the help you couldn't find is `expr-.` and `expr-..` (they're adjacent in the help file, no need to look them up separately). To quote the help doc:

> ```
> expr6 . expr6   String concatenation				*expr-.*
> expr6 .. expr6  String concatenation				*expr-..*
> 
> [...]
> 
> For String concatenation ".." is preferred, since "." is ambiguous, it
> is also used for |Dict| member access and floating point numbers. When
> |vimscript-version| is 2 or higher, using "." is not allowed.
> ```

And from `:h scriptversion-2`:

> ```
> <							*scriptversion-2*  >
> :scriptversion 2 
> String concatenation with "." is not supported, use ".." instead. 	This
> avoids the ambiguity using "." for Dict member access and 	floating
> point numbers.  Now ".5" means the number 0.5.
> ```

Similarly, Vim9 has also decided to step away from `.` for string concatenation, with the same reason: the operator is ambiguous. As someone who has personally "inherited" some pretty old code with some shockingly ambiguous use of the `.` operator (sequential variables that look like member access instead of concatenation), this is definitely noticeable. I digress, however.

To answer your question, there is no difference. It's the same operator doing the same thing. The only difference is that `.` is substantially more ambiguous due to its other uses, which made Vim introduce `..` to combat the ambiguity. You can use whichever you want, though the reason `..` is used in the first place is because Vim overall seems to want to push in the direction of that operator.

As for finding it, I personally wrote `:h .<tab>` and used [`wildmenu`](https://vi.stackexchange.com/a/11424/21251) to navigate until I found something that looked like it could be relevant ("`expr-.` looks awfully relevant given that it's used in an expression"). A more searchable option (in this case) would've been to use `:helpgrep \cstring concatenation` (`\c` means case-insensitive). This also gives a lot of additional help that covers `.` and `..`, and some of which again repeats how `.` is ambiguous and that `..` is preferred.

See also [this fantastic answer](https://vi.stackexchange.com/a/2137/21251) on navigating Vim's documentation - a part of it is still guessing relevant keywords, although that's not too different from using a search engine if you prefer thinking about it like that. (Documentation sprawl doesn't help either :) )