Sometimes Optimizations Cancel Each Other

I'm not convinced by the example.

The compiler will not assume that "i" variable may be reset to zero. "i" is defined in the loop statement, therefore it is obvious that there is no possibility of aliasing between "*p" and "i".
Even if "i" would be a local variable of the function containing the loop, it should be absolutely possible for the compiler to check aliasing between the two.

If you try and sell a source based product you certainly have to test on each platform.
As a programmer there is no way to avoid pitfalls as shown in your example. The only solution I can come up with is document each occurrence as a possible problem and formulate countermeasures (e.g. measurement tests) to be made on each platform before shipping.

The huge problem is that seemingly innocuous code is able to be the cause for a runtime issue later. It is rather difficult to identify all such occurrences in advance and have tests already in place for them, i.e. be 'truely' platform independent.

So, sometimes, I wish compiler optimizations were standardized so I could rely on them for once :)

A *huge* problem? I'm skeptical--such optimizations are often not critical. But on the other hand, why do you think that hand optimization won't make your program slower on some platforms? I've certainly seen it happen.
I think that If you care that much about run time, you have to measure every platform that's important to you.

Yes, portable code can be a challenge. I first make sure I am using the most efficient algorithm I can using portable C code, then compile and profile on each target platform.

At times I have found that tweaking the code can make an order of magnitude difference on one platform while causing very little impact on the others, but at other times you cannot get away without using the preprocessor to include different code on different platforms.

It is most certainly correct that the compiler usually *could* optimize code constructs better than the programmer could (e.g. the compiler is not limited by the expressiveness of the language!)
On the other hand, when wrinting portable code, a programmer can not *rely* on the compiler to do so because the compiler implementation is unknown.
In my experience that's a huge problem when confronted with a time critical section of code.