feat(divide-and-conquer): Add binary exponentiation algorithm

[dcq-31]

Add Binary Exponentiation algorithm to Divide and Conquer category

Summary

Adds Binary Exponentiation — the classic O(log n) fast-power algorithm — to the existing Divide and Conquer / Divide y vencerás category, which previously contained only Tower of Hanoi. Computes aⁿ by halving the exponent at each recursive step, visualized through the call stack concept so the logarithmic recursion depth is immediately visible.

This version is adapted to the current main architecture instead of the original older branch layout. The algorithm is wired through the catalog, dynamic loaders, localized content files, and per-language implementation packs so it works with the current app structure.

Changes

• New algorithm: src/lib/algorithms/divide-and-conquer.ts adds binaryExponentiation using the concept / callStack visualization and bilingual step descriptions via d().
• Registry: src/lib/algorithms/index.ts imports and registers the algorithm under the existing Divide and Conquer category.
• Catalog + loaders: src/lib/algorithms/catalog.ts and src/lib/algorithms/loaders.ts register the new binary-exponentiation id so routes, on-demand loading, and code pages resolve correctly.
• Localized content: src/content/algorithms/binary-exponentiation.ts adds English and Spanish long-form descriptions using the current content system.
• Language packs: divide-and-conquer implementation maps for C++, Java, Python, and Rust now include binary-exponentiation.
• READMEs: Adds Binary Exponentiation to the Divide & Conquer / Divide y vencerás sections in both README.md and README_ES.md. Also adds the previously omitted Bucket Sort entry to the Sorting / Ordenamiento sections — Bucket Sort was already implemented and registered but had not been listed in the READMEs.

Visualization

Trace of binPow(2, 10) = 1024 shown as an animated call stack:

1. Intro — frames the problem and the O(log n) idea.
2. Descent: each recursive call halves the exponent (10 → 5 → 2 → 1 → 0), showing the stack grow one frame at a time.
3. Base case at binPow(2, 0): returns 1.
4. Ascent: each frame resolves using either the even-exponent case (half × half) or the odd-exponent case (half × half × base).
5. Result: 2¹⁰ = 1024, demonstrating logarithmic recursion depth instead of linear repeated multiplication.

The same trace shows both cases naturally:

• Even exponent: binPow(2, 2) and binPow(2, 10)
• Odd exponent: binPow(2, 1) and binPow(2, 5)

[vercel]

@dcq-31 is attempting to deploy a commit to the midudev pro Team on Vercel.

A member of the Team first needs to authorize it.