Prevent offset access with block arrays to thwart dynamic ALA

[e-kayrakli]

This PR makes sure that ALA is applicable for:

var A = blockDist.createArray(...)
const InnerDomain = A.domain.expand(-1);

forall i in InnerDomain {
  A[i] = A[i-1];
}

Things of note:

• this is a dynamically optimized loop, because the compiler can't statically determine that InnerDomain and A.domain are aligned.
• the body contains both regular (A[i]) and offset (A[i-1]) access, where the latter is not optimizable for a block-distributed array

The problem is, #25712 modified the dynamic checks in scenarios like this. After that PR, the generated optimization looked like

param staticRegularFlag = alaStaticallySupported(A);  // added for A[i] (true)
param staticOffsetFlag = alaOffsetStaticallySupported(A);  // added for A[i-1] (false)

if ( (!staticRegularFlag || alaDynamicallySupported(A)) &&
                            alaOffsetCheck(A, 1)) {
  // optimized loop
}
else {
  // unoptimized loop
}

Note that ALA has static override (!staticRegularFlag || part) which allows optimization and the dynamic checks to be reverted in case a static check fails. This allows some accesses to be optimized while some others fails. However, the same override is not there for the offset check. This PR adds a similar !staticOffsetFlag || for similar purposes. This allows A[i] to be optimized as before while A[i-1] is not.

Test:

• performance goes back to where we were before
• gasnet
• linux64