Exercise 3: Deeply Nested Valid Input — Possible Solution
====================================================================

THE TEST
------------------------------
    test_input = "((([[[{{{}}}]]])))"
    expected = True

RESULT
------------------------------
    is_balanced_refactored('((([[[{{{}}}]]])))') = True, expected True: PASS

WHAT THIS CONFIRMS
------------------------------
The refactored implementation was cleaned up (tidier variable use, an
added tolerance for non-bracket characters) AFTER the chapter's own
full 7-case test suite already passed. This exercise adds an 8th case
that was never run against the code during either the original
implementation or the refactor - a genuinely deep, multi-type nesting
pattern - and it passes on the first try, with zero code changes.

That's exactly what a refactor is supposed to guarantee: the
implementation's own internal shape changed, but its behavior across
every input - including inputs nobody had specifically tested yet -
did not. A refactor that only happened to preserve behavior for the
inputs already in the test suite, but broke on a case like this one,
would be revealed by exactly the kind of test this exercise adds.

WHY THIS WORKS AS AN ANSWER
------------------------------
This is the same principle Clean Code, SOLID & Refactoring's own
capstone relied on throughout its six-step refactor: real confidence
in a refactor comes from behavior staying correct on cases beyond the
ones that happened to be tested during the refactor itself, not just
on the specific suite that was green at the time. A passing result
here, on a case invented after the fact, is stronger evidence of a
correct refactor than simply re-running the original 7 tests again
would have been.