Implement unified network layer with APILayer and migrate iOS ViewModels

Major architectural improvements:
- Created APILayer as single entry point for all network operations
- Integrated cache-first reads with automatic cache updates on mutations
- Migrated all shared Kotlin ViewModels to use APILayer instead of direct API calls
- Migrated iOS ViewModels to wrap shared Kotlin ViewModels with StateFlow observation
- Replaced LookupsManager with DataCache for centralized lookup data management
- Added password reset methods to AuthViewModel
- Added task completion and update methods to APILayer
- Added residence user management methods to APILayer

iOS specific changes:
- Updated LoginViewModel, RegisterViewModel, ProfileViewModel to use shared AuthViewModel
- Updated ContractorViewModel, DocumentViewModel to use shared ViewModels
- Updated ResidenceViewModel to use shared ViewModel and APILayer
- Updated TaskViewModel to wrap shared ViewModel with callback-based interface
- Migrated PasswordResetViewModel and VerifyEmailViewModel to shared AuthViewModel
- Migrated AllTasksView, CompleteTaskView, EditTaskView to use APILayer
- Migrated ManageUsersView, ResidenceDetailView to use APILayer
- Migrated JoinResidenceView to use async/await pattern with APILayer
- Removed LookupsManager.swift in favor of DataCache
- Fixed PushNotificationManager @MainActor issue
- Converted all direct API calls to use async/await with proper error handling

Benefits:
- Reduced code duplication between iOS and Android
- Consistent error handling across platforms
- Automatic cache management for better performance
- Centralized network layer for easier testing and maintenance
- Net reduction of ~700 lines of code through shared logic

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

Co-Authored-By: Claude <noreply@anthropic.com>

composeApp/src/commonMain/kotlin/com/example/mycrib/cache/DataCache.kt

@@ -4,6 +4,11 @@ import com.mycrib.shared.models.*
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import kotlin.time.Clock
+import kotlin.time.ExperimentalTime
+
+//import kotlinx.datetime.Clock
+//import kotlinx.datetime.Instant
 
 /**
  * Centralized data cache for the application.
@@ -44,17 +49,26 @@ object DataCache {
     val contractors: StateFlow<List<Contractor>> = _contractors.asStateFlow()
 
     // Lookups/Reference Data
-    private val _categories = MutableStateFlow<List<Category>>(emptyList())
-    val categories: StateFlow<List<Category>> = _categories.asStateFlow()
+    private val _residenceTypes = MutableStateFlow<List<ResidenceType>>(emptyList())
+    val residenceTypes: StateFlow<List<ResidenceType>> = _residenceTypes.asStateFlow()
 
-    private val _priorities = MutableStateFlow<List<Priority>>(emptyList())
-    val priorities: StateFlow<List<Priority>> = _priorities.asStateFlow()
+    private val _taskFrequencies = MutableStateFlow<List<TaskFrequency>>(emptyList())
+    val taskFrequencies: StateFlow<List<TaskFrequency>> = _taskFrequencies.asStateFlow()
 
-    private val _frequencies = MutableStateFlow<List<Frequency>>(emptyList())
-    val frequencies: StateFlow<List<Frequency>> = _frequencies.asStateFlow()
+    private val _taskPriorities = MutableStateFlow<List<TaskPriority>>(emptyList())
+    val taskPriorities: StateFlow<List<TaskPriority>> = _taskPriorities.asStateFlow()
 
-    private val _statuses = MutableStateFlow<List<Status>>(emptyList())
-    val statuses: StateFlow<List<Status>> = _statuses.asStateFlow()
+    private val _taskStatuses = MutableStateFlow<List<TaskStatus>>(emptyList())
+    val taskStatuses: StateFlow<List<TaskStatus>> = _taskStatuses.asStateFlow()
+
+    private val _taskCategories = MutableStateFlow<List<TaskCategory>>(emptyList())
+    val taskCategories: StateFlow<List<TaskCategory>> = _taskCategories.asStateFlow()
+
+    private val _contractorSpecialties = MutableStateFlow<List<ContractorSpecialty>>(emptyList())
+    val contractorSpecialties: StateFlow<List<ContractorSpecialty>> = _contractorSpecialties.asStateFlow()
+
+    private val _lookupsInitialized = MutableStateFlow(false)
+    val lookupsInitialized: StateFlow<Boolean> = _lookupsInitialized.asStateFlow()
 
     // Cache metadata
     private val _lastRefreshTime = MutableStateFlow<Long>(0L)
@@ -105,28 +119,15 @@ object DataCache {
         updateLastRefreshTime()
     }
 
-    fun updateCategories(categories: List<Category>) {
-        _categories.value = categories
-    }
-
-    fun updatePriorities(priorities: List<Priority>) {
-        _priorities.value = priorities
-    }
-
-    fun updateFrequencies(frequencies: List<Frequency>) {
-        _frequencies.value = frequencies
-    }
-
-    fun updateStatuses(statuses: List<Status>) {
-        _statuses.value = statuses
-    }
+    // Lookup update methods removed - lookups are handled by LookupsViewModel
 
     fun setCacheInitialized(initialized: Boolean) {
         _isCacheInitialized.value = initialized
     }
 
+    @OptIn(ExperimentalTime::class)
     private fun updateLastRefreshTime() {
-        _lastRefreshTime.value = System.currentTimeMillis()
+        _lastRefreshTime.value = Clock.System.now().toEpochMilliseconds()
     }
 
     // Helper methods to add/update/remove individual items
@@ -176,6 +177,35 @@ object DataCache {
         _contractors.value = _contractors.value.filter { it.id != contractorId }
     }
 
+    // Lookup update methods
+    fun updateResidenceTypes(types: List<ResidenceType>) {
+        _residenceTypes.value = types
+    }
+
+    fun updateTaskFrequencies(frequencies: List<TaskFrequency>) {
+        _taskFrequencies.value = frequencies
+    }
+
+    fun updateTaskPriorities(priorities: List<TaskPriority>) {
+        _taskPriorities.value = priorities
+    }
+
+    fun updateTaskStatuses(statuses: List<TaskStatus>) {
+        _taskStatuses.value = statuses
+    }
+
+    fun updateTaskCategories(categories: List<TaskCategory>) {
+        _taskCategories.value = categories
+    }
+
+    fun updateContractorSpecialties(specialties: List<ContractorSpecialty>) {
+        _contractorSpecialties.value = specialties
+    }
+
+    fun markLookupsInitialized() {
+        _lookupsInitialized.value = true
+    }
+
     // Clear methods
     fun clearAll() {
         _currentUser.value = null
@@ -187,14 +217,21 @@ object DataCache {
         _documents.value = emptyList()
         _documentsByResidence.value = emptyMap()
         _contractors.value = emptyList()
-        _categories.value = emptyList()
-        _priorities.value = emptyList()
-        _frequencies.value = emptyList()
-        _statuses.value = emptyList()
+        clearLookups()
         _lastRefreshTime.value = 0L
         _isCacheInitialized.value = false
     }
 
+    fun clearLookups() {
+        _residenceTypes.value = emptyList()
+        _taskFrequencies.value = emptyList()
+        _taskPriorities.value = emptyList()
+        _taskStatuses.value = emptyList()
+        _taskCategories.value = emptyList()
+        _contractorSpecialties.value = emptyList()
+        _lookupsInitialized.value = false
+    }
+
     fun clearUserData() {
         _currentUser.value = null
         _residences.value = emptyList()