Add horizontal scrolling support to onAdditionalLoading (#67)

## Summary

This PR adds horizontal scrolling support to the `.onAdditionalLoading`
modifier. Previously, the modifier only supported vertical scrolling,
but now it works with both horizontal and vertical scroll axes.

## Changes

- **Added `axis` parameter** to `AdditionalLoading` struct with default
value `.vertical`
- **Refactored `calculate` function** to use generic parameters instead
of Y-specific ones
- **Updated `_Modifier` implementation** to handle both horizontal and
vertical axes using switch statements
- **Added axis parameter to all public APIs**:
  - `ScrollView.onAdditionalLoading` (binding and non-binding overloads)
  - `List.onAdditionalLoading`
- `CollectionView.onAdditionalLoading` (binding and non-binding
overloads)
- **Added horizontal scrolling preview** demonstrating the new
functionality
- **Updated documentation** to reflect horizontal scrolling support

## Usage Example

### Horizontal scrolling
```swift
ScrollView(.horizontal) {
  LazyHStack {
    ForEach(items) { item in
      ItemView(item: item)
    }
  }
}
.onAdditionalLoading(
  leadingScreens: 1,
  axis: .horizontal,  // New parameter!
  isLoading: $isLoading,
  onLoad: {
    // Load more items...
  }
)
```

### Vertical scrolling (unchanged)
```swift
ScrollView {
  LazyVStack {
    ForEach(items) { item in
      ItemView(item: item)
    }
  }
}
.onAdditionalLoading(
  isLoading: $isLoading,  // axis defaults to .vertical
  onLoad: {
    // Load more items...
  }
)
```

## Backward Compatibility

All existing code continues to work without changes since the `axis`
parameter defaults to `.vertical`.

## Test Plan

- [x] All existing tests pass
- [x] Package builds successfully
- [x] Added horizontal scrolling preview for manual testing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <noreply@anthropic.com>

Author: muukii

Sources/CollectionView/CollectionView.swift

@@ -52,8 +52,10 @@ extension CollectionView {
   /// - Parameters:
   ///   - isEnabled: Toggles the behavior on or off. When `false`, no loading is triggered. Default is `true`.
   ///   - leadingScreens: The prefetch threshold expressed in multiples of the visible scrollable length
-  ///     (height for vertical layouts). For example, `2` triggers when the user is within two screenfuls
-  ///     of the end. Default is `2`.
+  ///     (height for vertical, width for horizontal). For example, `2` triggers when the user is within
+  ///     two screenfuls of the end. Default is `2`.
+  ///   - axis: The scroll axis to monitor. Use `.vertical` for vertical scrolling or `.horizontal` for
+  ///     horizontal scrolling. Default is `.vertical`.
   ///   - isLoading: A binding that reflects the current loading state. This modifier sets it to `true`
   ///     before calling `onLoad` and back to `false` when `onLoad` completes.
   ///   - onLoad: An async closure executed on the main actor when the threshold is crossed. Perform your
@@ -72,9 +74,9 @@ extension CollectionView {
   ///     values prefetch earlier.
   ///
   /// - SeeAlso:
-  ///   - ``onAdditionalLoading(isEnabled:leadingScreens:isLoading:onLoad:)`` (non‑binding overload)
-  ///   - ``ScrollView/onAdditionalLoading(isEnabled:leadingScreens:isLoading:onLoad:)``
-  ///   - ``List/onAdditionalLoading(isEnabled:leadingScreens:isLoading:onLoad:)``
+  ///   - ``onAdditionalLoading(isEnabled:leadingScreens:axis:isLoading:onLoad:)`` (non‑binding overload)
+  ///   - ``ScrollView/onAdditionalLoading(isEnabled:leadingScreens:axis:isLoading:onLoad:)``
+  ///   - ``List/onAdditionalLoading(isEnabled:leadingScreens:axis:isLoading:onLoad:)``
   ///
   /// - Platform:
   ///   - On iOS 18, macOS 15, tvOS 18, watchOS 11, and visionOS 2 or later, the modifier uses SwiftUI
@@ -95,6 +97,7 @@ extension CollectionView {
   ///       }
   ///       .onAdditionalLoading(isEnabled: true,
   ///                            leadingScreens: 1.5,
+  ///                            axis: .vertical,
   ///                            isLoading: $isLoading) {
   ///         // Fetch more and append
   ///         try? await Task.sleep(for: .seconds(1))
@@ -108,47 +111,51 @@ extension CollectionView {
   public func onAdditionalLoading(
     isEnabled: Bool = true,
     leadingScreens: Double = 2,
+    axis: Axis = .vertical,
     isLoading: Binding<Bool>,
     onLoad: @MainActor @escaping () async -> Void
   ) -> some View {
-    
-    self.onAdditionalLoading( 
+
+    self.onAdditionalLoading(
       additionalLoading: .init(
         isEnabled: isEnabled,
         leadingScreens: leadingScreens,
         isLoading: isLoading,
+        axis: axis,
         onLoad: onLoad
       )
     )
-    
+
   }
 
   /// Triggers a load-more action as the user approaches the end of the scrollable content,
   /// without managing any loading state internally.
-  /// 
+  ///
   /// This modifier observes the scroll position of the collection and invokes `onLoad` when
   /// the visible region nears the end of the content by the amount specified in `leadingScreens`.
   /// It is conditionally available when the ScrollTracking module can be imported.
-  /// 
+  ///
   /// Use this overload when you already manage loading state externally (e.g., in a view model)
   /// and simply want a callback to fire when additional content should be fetched. If you want
   /// the modifier to help manage loading state and support async work, consider the binding-based,
   /// async overload instead.
-  /// 
+  ///
   /// - Parameters:
   ///   - isEnabled: A Boolean that enables or disables additional loading. When `false`, no callbacks
   ///     are fired. Defaults to `true`.
-  ///   - leadingScreens: The prefetch distance, expressed as a multiple of the current viewport height.
-  ///     For example, `2` means `onLoad` is triggered once the user scrolls within two screen-heights
-  ///     of the end of the content. Defaults to `2`.
+  ///   - leadingScreens: The prefetch distance, expressed as a multiple of the current viewport length
+  ///     (height for vertical, width for horizontal). For example, `2` means `onLoad` is triggered once
+  ///     the user scrolls within two screen-lengths of the end of the content. Defaults to `2`.
+  ///   - axis: The scroll axis to monitor. Use `.vertical` for vertical scrolling or `.horizontal` for
+  ///     horizontal scrolling. Default is `.vertical`.
   ///   - isLoading: A Boolean that indicates whether a load is currently in progress. When `true`,
-  ///     additional triggers are suppressed. This value is read-only from the modifier’s perspective;
+  ///     additional triggers are suppressed. This value is read-only from the modifier's perspective;
   ///     you are responsible for updating it in your own state to avoid duplicate loads.
   ///   - onLoad: A closure executed on the main actor when the threshold is crossed and `isLoading` is `false`.
   ///     Use this to kick off your loading logic (e.g., dispatch an async task or call into a view model).
-  /// 
+  ///
   /// - Returns: A view that monitors scroll position and invokes `onLoad` as the user approaches the end.
-  /// 
+  ///
   /// - Discussion:
   ///   - The callback will not be invoked if the content is not scrollable, if `isEnabled` is `false`,
   ///     or while `isLoading` is `true`.
@@ -158,16 +165,16 @@ extension CollectionView {
   ///     are common depending on how early you want to prefetch.
   ///   - The `onLoad` closure runs on the main actor; if you need to perform asynchronous work,
   ///     start a `Task { ... }` inside the closure or delegate to your view model.
-  /// 
+  ///
   /// - SeeAlso: The binding-based async overload:
-  ///   `onAdditionalLoading(isEnabled:leadingScreens:isLoading:onLoad:)` where `isLoading` is a `Binding<Bool>`
+  ///   `onAdditionalLoading(isEnabled:leadingScreens:axis:isLoading:onLoad:)` where `isLoading` is a `Binding<Bool>`
   ///   and `onLoad` is `async`, which can simplify state management for loading.
-  /// 
+  ///
   /// - Example:
   ///   ```swift
   ///   struct FeedView: View {
   ///     @StateObject private var viewModel = FeedViewModel()
-  /// 
+  ///
   ///     var body: some View {
   ///       CollectionView(layout: viewModel.layout) {
   ///         ForEach(viewModel.items) { item in
@@ -177,6 +184,7 @@ extension CollectionView {
   ///       .onAdditionalLoading(
   ///         isEnabled: true,
   ///         leadingScreens: 1.5,
+  ///         axis: .vertical,
   ///         isLoading: viewModel.isLoading
   ///       ) {
   ///         // Executed on the main actor
@@ -189,14 +197,16 @@ extension CollectionView {
   public func onAdditionalLoading(
     isEnabled: Bool = true,
     leadingScreens: Double = 2,
+    axis: Axis = .vertical,
     isLoading: Bool,
     onLoad: @escaping @MainActor () -> Void
   ) -> some View {
-    self.onAdditionalLoading( 
+    self.onAdditionalLoading(
       additionalLoading: .init(
         isEnabled: isEnabled,
         leadingScreens: leadingScreens,
         isLoading: isLoading,
+        axis: axis,
         onLoad: onLoad
       )
     )