I do have one objective thing to say about readability. In a pop infix language like C, Python, Lua, or JS, the expression

    e(d(), c(b, a()))

    a b c d e

    a(); b(); c(); d(); e();  //none
    b(a); d(c); e();
    e(d(c, b()), a);
    {a, b, c, d, e} // all going somewhere else together

On this basis I think it's at least somewhat defensible to claim that stack languages are "less readable": information about the dataflow graph which is easily available in the infix syntax is not present, at least locally. You can reconstruct it by knowing, or guessing, the stack effect of each word. But that's different from just having it plainly written down.

As a result, in Forth and PostScript, I regularly have bugs where I pass a parameter to, or receive a result from, the wrong place. This is not a major practical problem (it's usually pretty easy to figure out in the REPL) but it serves as evidence that stack languages really do require more effort to read and understand than pop infix languages.

Of course, you can make almost exactly the same argument that explicit typing helps readability, and implicit variable capture by closures hurts it. I think there's some merit in that, actually.

Forth words are not functions and if you try and use them like functions, things will get messy. You should never have things like "a b c d e" in Forth, you should have "abcde," a single word with a descriptive name built from a, b, c, d, and e, and designed so all you have to worry about is the stack effect of "abcde" and not the words it is built on or the data flow. I would say this is like saying C is terrible because people do ridiculous things with macros.

I will give your posts a reread with fresh eyes tomorrow and probably have more to say, it is a bit too much to digest at this hour.