... because it's been designed and implemented to operate the way it does — that's all :)

I think the crucial difference is that the normal assignment
operator (=) does not force scalar context upon its LHS (so the
array remains an array, not the number of its elements), while ||=
does. It's not so much an issue of not being able to assign a scalar to an array, but rather the problem of the array no longer being (treated like) an array internally...

On the other hand, it would be useful to expand the definition of the ||= operator so that (@a ||= EXPR) means (@a = @a ? @a : EXPR).
Similarly, it could be useful to expand the definition of &&= such that (@a &&= EXPR) means (@a = @a ? EXPR : ()).
However, none of **=, +=, *=, &=, <<=, -=, /=, |=, >>=, .=, %=, ^=, //= and x= would be useful for arrays.

So,
if the context of the "," operator is known to be scalar at compile-time, the LHS is evaluated in void context.
if the context of the "," operator is known to be list at compile-time, the LHS is evaluated in list context.
if the context of the "," operator is not known at compile-time, the LHS is evaluated in the same context as the operator.

I'd say the problem is that you're evaluating @bar in scalar
context (which gives the number of elements in the array), and that
you're then trying to modify that number (which you can't). This is
similarly nonsensical as @bar++, or @bar += 5, or @bar |= 1, etc. All of those assume/force scalar context on the left hand side.