Add wp_mobile service layer with observable entity pattern

[oguzkocer]

This PR introduces wp_mobile, a mobile-friendly service layer that provides observable entities and collections with automatic cache management. The design enables reactive UIs on iOS/Android by bridging Rust database updates to platform-native observers.

1. wp_mobile_cache: Repository Pattern & Change Notifications

Key Changes:

• EntityId system: Universal identifier for cached entities across language boundaries (DbSite + table_name + rowid)
• FullEntity wrapper: Combines EntityId with entity data for consistent API returns
• Repository pattern: All repositories now return EntityId from upsert operations
• Database change hooks: DatabaseDelegate trait allows platforms to observe all database updates via UpdateHook
• DbTable enum: Single source of truth for table names, prevents string typos

Design rationale: EntityId provides a stable, UniFFI-compatible reference to cached data. The delegate pattern enables platform-specific reactive patterns without coupling the cache to any particular UI framework.

2. wp_mobile: Service Layer & Observable Entities

Architecture:

┌─────────────────────────────────────────────────────┐
│  Platform (iOS/Android)                             │
│  ┌──────────────────────────────────────────────┐   │
│  │  ViewModel observes Entity/Collection        │   │
│  └──────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────┘
                      ▲
                      │ UniFFI bindings
                      ▼
┌─────────────────────────────────────────────────────┐
│  wp_mobile (Rust)                                   │
│  ┌──────────────────┐  ┌──────────────────────────┐ │
│  │ Entity<T>        │  │ PostCollection<T>        │ │
│  │ - load_data()    │  │ - filter()               │ │
│  │ - is_relevant()  │  │ - fetch_page()           │ │
│  └──────────────────┘  │ - load_data()            │ │
│                        └──────────────────────────┘ │
│  ┌──────────────────────────────────────────────┐   │
│  │ PostService / SiteService                    │   │
│  │ - Create entities/collections                │   │
│  │ - Coordinate network + cache                 │   │
│  └──────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────┘
                      ▲
                      │ Uses repositories
                      ▼
┌─────────────────────────────────────────────────────┐
│  wp_mobile_cache                                    │
│  - PostRepository, SiteRepository                   │
│  - SQLite storage                                   │
└─────────────────────────────────────────────────────┘

Key Components:

Entity Pattern:

• Entity<T>: Lightweight handle to cached data with load_data() and is_relevant_update() methods
• Stateless design: no cached data in memory, always reads from DB
• wp_mobile_entity! macro generates UniFFI-compatible wrappers for each context (Edit/View/Embed)

Collection Pattern:

• StatelessCollection: Generic collection with closure-based filtering and multi-table observation
• PostCollection: Domain-specific collection with filtering (AnyPostFilter) and pagination (fetch_page())
• Both support load_data() to query all matching items from cache

Services:

• PostService: Factory for post entities and collections, coordinates network fetch + cache
• SiteService: Manages site lookup and creation for self-hosted sites

Design decisions:

• Stateless by design: Entities don't cache data to avoid stale state and memory overhead
• Async-only API for UniFFI: load_data() is exported as async fn to encourage background thread usage in Kotlin/Swift (Rust implementation is sync since rusqlite doesn't support async)
• Observable without coupling: is_relevant_update() allows platforms to implement their own observer patterns

3. Kotlin: Observable Wrappers with Lifecycle Management

New Components:

DatabaseChangeNotifier (singleton):

• Implements DatabaseDelegate to receive all Rust database updates
• Broadcasts updates to registered ObservableEntity and ObservableCollection instances

ObservableEntity<D> / ObservableCollection<D>:

• Platform-native observer pattern wrapping Rust entities/collections
• addObserver() / removeObserver() for reactive UI updates
• AutoCloseable implementation for proper lifecycle management
• Created via service extensions: postService.getObservableEntityWithEditContext(entityId)

WordPressApiCache:

• Kotlin wrapper for WpApiCache that auto-registers DatabaseChangeNotifier
• Provides convenient constructors (in-memory, path-based)

Lifecycle pattern:

class MyViewModel : ViewModel() {
    private val observable = postService.getObservableEntityWithEditContext(postId)

    init {
        observable.addObserver { /* update UI */ }
    }

    override fun onCleared() {
        observable.close() // Unregisters from DatabaseChangeNotifier
        super.onCleared()
    }
}

Design rationale: AutoCloseable provides idiomatic Kotlin lifecycle management without forcing weak references or complex cleanup logic. The observer pattern is familiar to Android/Compose developers.

4. Kotlin Example App: Reference Implementation

Two demo screens showcase the observable pattern:

Stress Test Screen:

• Generates 1000 posts with background batch updates (1-20 posts per batch, variable timing)
• Displays real-time performance metrics (avg/min/max load times, total latency)
• Demonstrates scalability of observable pattern with frequent updates

Post Collection Screen:

• Interactive filtering (All / Drafts / Published)
• Pagination with fetch_page()
• Shows cached post count, pages fetched, total items
• Demonstrates practical usage of PostCollection with filtering and network operations

DI Setup (Koin):

• Disk-based cache with temp file (auto-deletes on exit)
• MockPostService for generating test data
• WpSelfHostedService with authentication
• ViewModels as singletons (acceptable for example app, not production pattern)

Purpose: Serves as reference for integrating wp_mobile into real apps. Shows proper lifecycle management, reactive UI patterns, and how to use entities/collections.

---

Summary

This PR establishes the foundation for mobile-native WordPress data access with:

• Rust core: Stateless entity/collection pattern with database change notifications
• Kotlin bindings: Observable wrappers with AutoCloseable lifecycle management
• Reference app: Working examples of filtering, pagination, and real-time updates

The design prioritizes simplicity (stateless), performance (no memory caching), and platform flexibility (observers via is_relevant_update, not prescriptive state management).