feat(data-structures/unstable): add RollingCounter serialization

[tomas-zijdemans]

• Add toJSON() / RollingCounter.from() for JSON-compatible serialization and restoration
• Add current getter for reading the newest segment without iteration
• Add Symbol.toStringTag to match module precedent.

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 94.43%. Comparing base (1cd63ca) to head (afca513).
⚠️ Report is 6 commits behind head on main.

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #7074      +/-   ##
==========================================
+ Coverage   94.41%   94.43%   +0.02%     
==========================================
  Files         630      630              
  Lines       50490    50601     +111     
  Branches     8949     8978      +29     
==========================================
+ Hits        47669    47785     +116     
+ Misses       2249     2247       -2     
+ Partials      572      569       -3     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[bartlomieju]

The rotate() optimization: could you share the benchmarks that motivated this rewrite? The original 4-line loop was simple and correct — the new version is ~25 lines with wrap-around logic and already introduced a cursor corruption bug (rotate(0)).

Modulo per iteration is cheap on modern engines, so I'd want to see concrete numbers before trading readability for this. What was the benchmark setup (segment count, step sizes) and what workload are you optimizing for?

If the gains are significant for your use case, this might be better as a separate PR with the benchmarks included so the tradeoff is documented.

[tomas-zijdemans]

Below is the benchmark.

The speedup is small for regular rotation (the most common use case). I'm seeing an average of about 10% improvement across sizes. The big winner is, the arguably lot less used, bulk rotation seeing 5.5x to 7.5x.

I will revert the perf changes, and then we can see if that's something we want to introduce in a future PR. The readability hit is real, fully agree on that!

import { RollingCounter } from "./unstable_rolling_counter.ts";

// --- rotate(1): the common case ---

const small1 = new RollingCounter(5);
Deno.bench({
  group: "rotate(1)",
  name: "5 segments",
  fn: () => {
    small1.increment(1);
    small1.rotate();
  },
});

const med1 = new RollingCounter(60);
Deno.bench({
  group: "rotate(1)",
  name: "60 segments",
  fn: () => {
    med1.increment(1);
    med1.rotate();
  },
});

const large1 = new RollingCounter(1000);
Deno.bench({
  group: "rotate(1)",
  name: "1000 segments",
  fn: () => {
    large1.increment(1);
    large1.rotate();
  },
});

// --- bulk rotate ---

const medHalf = new RollingCounter(60);
Deno.bench({
  group: "rotate(n) bulk",
  name: "60 segments, rotate(30)",
  fn: () => {
    medHalf.increment(1);
    medHalf.rotate(30);
  },
});

const largeHalf = new RollingCounter(1000);
Deno.bench({
  group: "rotate(n) bulk",
  name: "1000 segments, rotate(500)",
  fn: () => {
    largeHalf.increment(1);
    largeHalf.rotate(500);
  },
});

const largeMost = new RollingCounter(1000);
Deno.bench({
  group: "rotate(n) bulk",
  name: "1000 segments, rotate(999)",
  fn: () => {
    largeMost.increment(1);
    largeMost.rotate(999);
  },
});