Why are functional programs considered slower than procedural counterparts asymptotically, if the opposite appears true?
Without fully answering your question, I would like to answer it at
least partially by remarking that computation cost can be evaluated
only with respect to an abstract model of computation.

If you want to use two different models, for two different programs,
than you have to determine the complexity of reducing each model to
the other, in order to have a meaningful comparison.

Another point is that physics does not well qualify as a computation
model for several reasons:


it is not clear enough what physics allows and does not allow regarding of computation, computation speed, storage, etc.
computation models are defined with various assumptions about unit
operations and their costs, and about infinity and asymptotics,
which are not meant to be a reflection of reality, but only an
approximation of reality intended to facilitate the analysis of
some phenomena, whether abstract or physical.

This is why Turing machines are more appropriate than finite
automata theory to analyse the behavior of devices with very large,
though still finite memory. For example, the powerset construction
of DFA may exist in theory when the memory is finite, however big,
but may also quickly exceed the capacity of our limited universe,
thus hardly making any sense.


Considering your first example about the "physical" time cost of
executing a for loop on an array of size $n$. If we are to do
asymptotic physics, we have to do it right, or at least as right as
current knowledge in physics will allow. Due to universe expansion,
the part of the universe that we can ever hope to access is bounded by
a radius of some $z$ zillion light-years (corresponding to a distance
at which the expansion speed relative to us equals the speed of
light), so that nothing relevant to us can be further away.

You can see that as good news: distances being bounded, access is
asymptotically in constant time, so that the classically accepted cost
analysis does hold, despite your remarks.

Of course, since you still want to have arbitrarily large memory, you
have to assume that this finite sphere can hold infinitely many bits
of information ... which I fear physicists cannot really tell. But
let's be optimistic.

Another way to do away with your remark is to consider that the access
time is small enough that it will not really impact the computing
time, unless you have specific reasons to think otherwise.

Some high speed computer do have to be programmed taking into account
physical distances, in particular to memory. But why should functional
program be exempted from such physical limitations. How much
computational capacity do you store with each cell?  Instead of the
$+$ operator, can you pass any arbitrarily complex fuction as
parameter and still have it reduced locally in each memory cell.

Or to put it differently, what prevents an imperative program from
taking advantage of an architecture that has computing power in each
memory cell. This is remindful of various specialized architectures,
such as vector processors.