Add window resize handling with responsive behavior

[thomasnemer]

Summary

Implements comprehensive window resize handling throughout the component hierarchy, enabling automatic layout reflow when the window size changes.

⚠️ Note: This is a draft PR with known issues documented in #109. The per-axis resize behavior implementation conflicts with pre-existing component sizing behaviors and needs refinement before merge.

Features Added

• AxisResizeBehavior enum: Independent control of horizontal/vertical resize behavior (FIXED, SCALE, FILL)
• Per-axis resize: setAxisResizeBehavior(horizontal, vertical) for fine-grained control
• ResizeBehavior enum: Four unified behavior options (FIXED, SCALE, FILL, MAINTAIN_ASPECT)
• ResponsiveConstraints: Support for min/max dimensions and aspect ratio constraints
• Automatic propagation: Resize events automatically propagate through the component hierarchy
• FlexLayout integration: Per-axis behavior works with FlexLayout's grow/shrink factors
• Scene integration: Scene captures window resize events and triggers propagation
• Comprehensive tests: Test suites validate all behaviors including per-axis resizing

Known Issues (see #109)

1. Jumping effect: Initial layout differs from post-resize layout, causing visible jump on first resize
2. Asymmetric resize: Components may grow but not shrink correctly
3. Behavior conflicts: Multiple sizing systems (FlexLayout, withSize(), resize behavior) have unclear precedence

These issues are being tracked in #109 and will be addressed before this PR is merged.

Changes

• Component (include/bombfork/prong/core/component.h):
  • Added AxisResizeBehavior enum for per-axis control
  • Added setAxisResizeBehavior() method
  • Enhanced setBounds() to respect per-axis behavior
  • Added onParentResize() with automatic behavior handling
  • Added ResponsiveConstraints support
• Scene (include/bombfork/prong/core/scene.h): Updated resize propagation
• Panel (include/bombfork/prong/components/panel.h): Added resize behavior support
• Demo app (examples/demo_app/scenes/demo_scene.h):
  • Configured panels with per-axis resize behavior
  • Left/right panels: FIXED horizontal, FILL vertical
  • Center panel: FILL both axes
• Tests:
  • tests/test_component_resize.cpp - Unified resize behavior tests
  • tests/test_axis_resize.cpp - Per-axis resize behavior tests
  • tests/test_resize_shrink.cpp - Shrink behavior tests
• Documentation (CLAUDE.md): Added comprehensive resize behavior documentation

Test Plan

• All unit tests pass (17/17 including new per-axis tests)
• Build succeeds with mise build
• Tests build with mise build-tests
• Demo app builds with mise build-examples
• ⚠️ Demo app shows known issues (jumping, inconsistent shrinking)

Usage Example

// Per-axis control (recommended for FlexLayout)
auto leftPanel = create<FlexPanel>().withSize(300, 0).build();
leftPanel->setAxisResizeBehavior(Component::AxisResizeBehavior::FIXED,   // horizontal
                                 Component::AxisResizeBehavior::FILL);    // vertical

// Unified control
auto panel = create<Panel<>>().build();
panel->setResizeBehavior(Component::ResizeBehavior::FILL);

// With constraints
Component::ResponsiveConstraints constraints;
constraints.minWidth = 200;
constraints.maxWidth = 600;
panel->setConstraints(constraints);

Related to #7
Blocked by #109

[thomasnemer]

Fix Applied: Resize Shrinking Now Works Correctly

I've identified and fixed a critical bug in the resize implementation where SCALE and MAINTAIN_ASPECT behaviors didn't work correctly when shrinking windows.

The Problem

The original implementation scaled from the current dimensions rather than the original dimensions:

// ❌ WRONG - scales from current size (compounds errors)
int newWidth = static_cast<int>(width * scaleX);

This caused:

• Growing worked: 100×100 → 200×200 (2x) ✓
• Shrinking failed: Should go to 50×50 (0.5x) but stayed at 100×100 ✗

The Solution

Now we store the original dimensions on first resize and always scale from those:

// ✅ CORRECT - scales from original size
int newWidth = static_cast<int>(originalWidth * scaleX);

Changes in Latest Commit (d1e0705)

1. Added 4 new member variables to track original dimensions:

   • originalLocalX, originalLocalY (position)
   • originalWidth, originalHeight (size)

2. Fixed SCALE behavior - now scales from original dimensions in both directions

3. Fixed MAINTAIN_ASPECT behavior - now scales from original aspect ratio

4. Enhanced test coverage - added shrink tests to verify both grow and shrink work

Test Results

All tests pass (16/16) including new shrink scenarios:

• ✅ FILL: Grow 800×600 → 1024×768 → Shrink to 640×480
• ✅ SCALE: Grow 2x then shrink to 0.5x - dimensions correct
• ✅ MAINTAIN_ASPECT: Maintains aspect ratio when shrinking

The resize system now properly handles window size changes in both directions!

[thomasnemer]

Second Fix: setBounds() Now Propagates Resize to Children

Found and fixed the actual root cause of why the demo app wasn't shrinking!

The Real Problem

The first fix made SCALE behavior work correctly, but the demo app still didn't shrink. Here's why:

Broken resize propagation chain:

1. Window shrinks → Root container's onParentResize() called ✓
2. Root container resizes and calls invalidateLayout() ✓
3. FlexLayout recalculates and calls setBounds() on child panels ✓
4. Child panels resize BUT... ✗
5. setBounds() didn't notify the children! ✗
6. Grandchildren stayed at original size and got cropped ✗

Root Cause

setBounds() only updated the component's own dimensions without propagating to children. This broke the resize chain when layout managers repositioned components.

// ❌ BEFORE - children never notified
virtual void setBounds(int x, int y, int w, int h) {
    width = w;
    height = h;
    // ... but children still think parent is old size!
}

The Solution (commit 3f09c05)

Modified setBounds() to automatically call onParentResize() on all children when the size changes:

// ✅ AFTER - resize propagates through entire tree
virtual void setBounds(int x, int y, int w, int h) {
    bool sizeChanged = (width != w || height != h);
    width = w;
    height = h;
    
    if (sizeChanged) {
        for (auto& child : children) {
            child->onParentResize(w, h);  // Notify children!
        }
    }
}

This ensures resize propagation works correctly throughout the entire component hierarchy, regardless of whether the resize is triggered by:

• Window resize events (direct onParentResize() calls)
• Layout managers (calling setBounds() during layout recalculation)
• Manual programmatic resize

Test Results

All 16 tests pass, including resize tests that verify propagation through multiple levels of hierarchy.

The demo app should now properly shrink when you reduce the window size - all components in the hierarchy will receive resize notifications and apply their resize behaviors!