Fix multicategory axes ordering second-level categories globally

On a multicategory axis, second-level categories were keyed on where
each label first appears anywhere in the data, so every first-level
category rendered the same child sequence regardless of its own data
order.

Track children per parent instead: collect parents in first-appearance
order and each parent's children in the order its own data supplies
them, then emit the pairs directly - no flat row list and no sort
needed, as setCategoryIndex already dedups.

The lookups are now prototype-less objects, so a category named e.g.
'toString' no longer resolves through Object.prototype and ends up
without an index.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VuN1reWCtHE6WFsNZjdGCD

Author: claude

src/plots/cartesian/set_convert.js

@@ -371,10 +371,15 @@ module.exports = function setConvert(ax, fullLayout) {
                 }
             }
 
-            // [ [cnt, {$cat: index}], for 1,2 ]
-            var seen = [[0, {}], [0, {}]];
-            // [ [arrayIn[0][i], arrayIn[1][i]], for i .. N ]
-            var list = [];
+            // first-level categories in first-appearance order
+            var parents = [];
+            // {$parentCat: {seen: {$childCat: 1}, children: [$childCat, ..]}}
+            // second-level categories are tracked *per parent*, so that each
+            // parent keeps the child order found in its own data rather than
+            // sharing one global order across all parents.
+            // prototype-less objects so that e.g. a category named 'toString'
+            // does not resolve through Object.prototype
+            var childrenOf = Object.create(null);
 
             for(i = 0; i < traceIndices.length; i++) {
                 var trace = fullData[traceIndices[i]];
@@ -389,31 +394,27 @@ module.exports = function setConvert(ax, fullLayout) {
                             var v1 = arrayIn[1][j];
 
                             if(isValidCategory(v0) && isValidCategory(v1)) {
-                                list.push([v0, v1]);
-
-                                if(!(v0 in seen[0][1])) {
-                                    seen[0][1][v0] = seen[0][0]++;
+                                if(!(v0 in childrenOf)) {
+                                    childrenOf[v0] = {seen: Object.create(null), children: []};
+                                    parents.push(v0);
                                 }
-                                if(!(v1 in seen[1][1])) {
-                                    seen[1][1][v1] = seen[1][0]++;
+
+                                var kids = childrenOf[v0];
+                                if(!(v1 in kids.seen)) {
+                                    kids.seen[v1] = 1;
+                                    kids.children.push(v1);
                                 }
                             }
                         }
                     }
                 }
             }
 
-            list.sort(function(a, b) {
-                var ind0 = seen[0][1];
-                var d = ind0[a[0]] - ind0[b[0]];
-                if(d) return d;
-
-                var ind1 = seen[1][1];
-                return ind1[a[1]] - ind1[b[1]];
-            });
-
-            for(i = 0; i < list.length; i++) {
-                setCategoryIndex(list[i]);
+            for(i = 0; i < parents.length; i++) {
+                var children = childrenOf[parents[i]].children;
+                for(j = 0; j < children.length; j++) {
+                    setCategoryIndex([parents[i], children[j]]);
+                }
             }
         };
     }

test/jasmine/tests/axes_test.js

@@ -4354,6 +4354,27 @@ describe('Test axes', function() {
                 expect(ax._categoriesMap).toEqual({'1,a': 0, '1,b': 1, '2,a': 2, '2,b': 3});
             });
 
+            it('should order second-level categories per parent, not globally', function() {
+                var out = _makeCalcdata({
+                    x: [['1', '1', '2', '2'], ['b', 'a', 'a', 'b']]
+                }, 'x', 'multicategory');
+
+                // '2' keeps its own 'a' then 'b' order, even though 'b' is
+                // the first second-level category seen overall (under '1')
+                expect(out).toEqual([0, 1, 2, 3]);
+                expect(ax._categories).toEqual([['1', 'b'], ['1', 'a'], ['2', 'a'], ['2', 'b']]);
+                expect(ax._categoriesMap).toEqual({'1,b': 0, '1,a': 1, '2,a': 2, '2,b': 3});
+            });
+
+            it('should not let second-level categories inherit the prototype chain', function() {
+                var out = _makeCalcdata({
+                    x: [['1', '1'], ['toString', 'a']]
+                }, 'x', 'multicategory');
+
+                expect(out).toEqual([0, 1]);
+                expect(ax._categories).toEqual([['1', 'toString'], ['1', 'a']]);
+            });
+
             it('case invalid in x[0]', function() {
                 var out = _makeCalcdata({
                     x: [['1', '2', null, '2'], ['a', 'a', 'b', 'b']]