Как вы сказали, выражение оценивается слева направо, то есть при первом обнаружении a его значение по-прежнему равно 5. Это сводится к:

var a = 5, b = 3; 
a = ( a -( b = ( a = a+b ) - b ) );
a = 5 - (b = (a=(5+3)) - b);
a = 5 - (b = 8 - b);
a = 5 - 5; AND b = 5

Во втором, значение a оценивается после присваивания, потому что оно находится справа

var a = 5, b = 3;
a = ( ( b = ( a = a+b ) - b ) - a );
a = ( ( b = 8 - b ) - a ); AND a = 8
a = ( 5 - 8 ); AND a = 8; AND b = 5;
a = - 3;

Все сводится к порядку вычисления операндов.

Обычно в первом случае a оценивается как 5, затем оценивается b = ( a = a+b ) - b, и только во время этой оценки значение a изменяется, но не переносится обратно.

Во втором примере сначала вычисляется ( b = ( a = a+b ) - b ), меняя значение a на 8, затем вычисляется a, и оказывается, что оно равно 8.

Более тривиальный пример:

var a = 5
a = a + (a = 2)
// a = 7

a оценивается как 5, затем (a = 2) оценивается как 2 и a устанавливается в 2, затем оценивается 5+2 и устанавливается значение 7.

С другой стороны :

var a = 5
a = (a = 2) + a
// a = 4

(a = 2) оценивается как 2 и a устанавливается на 2, затем a оценивается как 2, затем оценивается 2+2 и a устанавливается на 4

Вот объяснение, я надеюсь, оно ясное, потому что оно не так очевидно. JS и все другие языки создают дерево для оценки выражений. В дереве каждому оператору присваивается вес в зависимости от их положения и фигурных скобок.

Во-первых, вот шаги, которые JS обработал бы выражением:

Step 0. a = ( a - ( b = ( a = a+b ) - b ) );   a=5, b=3
Step 1.                   a = a+b              a=8, b=3
Step 2.             b = a - b                  a=8, b=5 
Step 3. a = a - b                              a=0, b=5

На каждом шаге обрабатывается один оператор.

И это дерево, которое он создает из вашего выражения:

    =
  /   \
 a     - 
     /    \
   a       =
          /  \   
         b    -            
             / \
            =   b
           /  \
          a    +
              / \
             a   b

Затем дерево обрабатывается снизу вверх.

var a = 5, b = 3;
a = ( ( b = ( a = a+b ) - b ) - a );

Так он и будет работать.

a = a + b //8
b = a - b //8-3=5
a = b - a //5-8=-3

var a = 5, b = 3; 
a = ( a -( b = ( a = a+b ) - b ) );

1) a = a (5) - (остальная часть выражения, где скоро будут вычислены 2 части)

2) b = (a = a + b // и он все еще не вычислен) - b (который равен 3, потому что новый b еще не изменен)

3) a = 5(a) + 3(b) = 8

4) b (мы вернулись к пункту 2) = 8 (новый a) - 3 (старый b) = 5

5) а (точка 1) = 5 (старый а) - 5 (новый б) = 0

Новый a = 0, новый b = 5

var a = 5, b = 3; 
a = ( ( b = ( a = a+b ) - b ) - a );

1) b = ( a = a+b ) - 3(b)

2) a = 5(a) + 3(b) = 8

3) б = 8 (новый а) - 3 (старый б) = 5

4) а (финал) = 5 (новый б) - 8 (новый а) = -3

Новый a = -3, новый b = 5

Надеюсь читабельно: D

a = ( a -( b = ( a = a+b ) - b ) ) 

похоже на это

a = ( 5 -( b = ( a = 5+3 ) - 3 ) ) // a = 8
// a = ( 5 - ( b = 8 - 3 ) ) // b = 5
// a = ( 5 - 5 ) // a = 0

это означает, что он заменит a и b в левой части = за один раз с одинаковыми начальными значениями, это не похоже на эту последовательность

a = a+b; // a = 8
b = a-b; // b = 5
a = a-b; // a = 3

как вы ожидаете.