The difference is that arrays are by-value — they have all own copies which are all individually iterated. [At least that's how they function semantically.]
Iterators though are objects and thus share a common state.

It's not like arrays would be seeking each time and iterators not. Just each foreach works on its own array copy, but shares the object.

I get what you're saying, arrays are by value. Objects, starting from PHP5, are by reference. Still if I unset an element of the same array in the nested foreach I get that element wiped in the main array as well.

$a = [1, 2, 3, 4];

foreach ($a as $i => $v) {
    foreach ($a as $i2 => $v2) {
        if ($i2 % 2 == 0) {
            unset($a[$i2]);
        }
    }
}

var_dump($a); // it prints 2, 4 (of course)

If each foreach is working with its own array copy like you said then there's probably a scope issue?
The whole thing is confusing because someone would think that iterators work just like a normal array but then, even if we don't implement a thing and use the ready-to-use ArrayIterator class, we get a completely different behaviour with a simple thing like a nested foreach. It's not just a completely different behaviour, it's just unreliable. The ArrayIterator class, as it is, can't even be used in a nested foreach unless we start setting positions manually. That would probably make us loose the benefit of using iterators in the first instance.

When you unset $a[$i2], you're removing the element from $a, not from the copy being iterated over. Each loop starts by getting a copy of $a as it exists at that moment.

$a = [1,2,3,4];
foreach ($a as $i => $v) {
	echo 'outer loop: ', $v, ' ', join(",", $a),"\n";
    foreach ($a as $i2 => $v2) {
		echo 'inner loop: ', $v2, ' ', join(",", $a),"\n";
        if ($i2 % 2 == 0) {
			echo "Drop $i2\n";
            unset($a[$i2]);
        }
    }
}

That's all right because it's how arrays are meant to work. Most languages out there work this way. The problem is that a feature has been added and it doesn't work as anyone would assume. A language feature should be there to solve a problem and make developers' lives easier. Instead, in this specific case, I think it just makes applications written with iterators error-prone. It also add a complexity that in my opinion make loose the benefit of using iterators in the first instance. A similar thing happens if you unset an element in one of the two foreach loops. The internal pointer is incremented, then you reach the end of the foreach loop where you unsetted the element and the internal pointer gets incremented again. Outcome is that the parent loop skips an element. Isn't all this at least worth a warning in the docs in your opinion?