Aggregation support (#1328)

* Implement data aggregation (day, week, month, year) across the Overview and Table screens to improve long-term data visualization and management.

### Core Changes
- **Data Aggregation Engine**: Introduced `MeasurementAggregationUseCase` to group and average measurements by time period, including automatic trend and difference calculations between periods.
- **Enhanced `MeasurementFacade`**: Updated the data pipeline to support optional aggregation levels as a final processing step.
- **Interactive Drill-down**:
    - Overview and Table screens now support a "drill-down" mode to view raw measurements for a specific aggregated period.
    - Aggregated Table rows now feature a `ChevronRight` icon to navigate to period details.
- **Unified Filtering**: Updated the filter menu in Graph, Table, and Overview screens to include a new "Aggregation" section.
- **UI Enhancements**:
    - Aggregated list items now display the number of raw measurements in the period.
    - Added an average symbol (⌀) prefix for values representing aggregated periods.
    - Updated `MeasurementCard` and `TableScreen` to handle period-based selection and batch actions (Delete/Export/Change User).

### Localization & Navigation
- Added string resources for aggregation levels (None, Day, Week, Month, Year) in English and German.
- Registered new drill-down routes in `AppNavigation` and `Routes`.
- Updated `Enums.kt` to include `AggregationLevel` and restored Hebrew (iw) to the language list.

* Introduce `AggregatedMeasurement` model and unify data access through a centralized `screenFlow` in `SharedViewModel`.

- Create `AggregatedMeasurement` model to encapsulate enriched measurements with period metadata (start/end bounds, count, and stable keys).
- Add `screenFlow` to `SharedViewModel` as a reactive, cached entry point for screens, handling user selection, time-range resolution, and aggregation logic internally.
- Add `drillDownFlow` to `SharedViewModel` for accessing raw measurements within fixed time windows.
- Refactor `OverviewScreen`, `TableScreen`, `GraphScreen`, and `StatisticsScreen` to consume the unified flows, simplifying UI logic.
- Move period labeling and bound calculation logic into `AggregationLevel` enum.
- Update `MeasurementFacade` to support the new aggregated pipeline and improve type safety.
- Optimize chart data loading by reusing the cached `screenFlow`.

* Improve data pipeline stability and UI performance in the Overview and Table screens with the following changes:

*   **ViewModel & Data Flow**:
    *   Switch `StateFlow` sharing strategies from `WhileSubscribed(5000)` to `Eagerly` for `selectedUserId`, `selectedUser`, `measurementTypes`, and measurement flows. This prevents UI flickers, empty-list flashes, and accidental pipeline teardowns during navigation.
    *   Implement a cache for `drillDownFlow` and include `useSmoothing` in the `screenFlow` cache key to prevent redundant cold flow restarts and state collisions.
    *   Fix `MeasurementFilterUseCases` to correctly handle null bounds, ensuring inclusive filtering for start and end timestamps.

*   **Performance Optimizations**:
    *   Introduce `remember`ed lookup maps (O(1)) in `OverviewScreen` and `TableScreen` for aggregated items and measurement types, replacing linear scans during recomposition.
    *   Reuse pre-computed period bounds from `AggregatedMeasurement` instead of recomputing them in the UI layer.

*   **Table Screen & Selection Mode**:
    *   Fix selection logic in aggregated mode by using `filter` and `first` on `StateFlows` to avoid capturing initial `Loading` states.
    *   Optimize multi-item operations (delete/change user) by snapshotting data before processing, preventing "missing item" errors when Room emits updates mid-loop.
    *   Enable selection mode and filter actions within the drill-down view.
    *   Refactor selection state management to use `Set<String>` for more efficient toggling and updates.

* Refactor measurement smoothing to apply after aggregation.

Specific changes:
- In `MeasurementFacade`, reordered the processing pipeline to perform data aggregation before applying smoothing algorithms.
- Updated `MeasurementSmoothingUseCases` to operate on `AggregatedMeasurement` instead of `EnrichedMeasurement`, ensuring smoothing is applied to averaged period values.
- In `SharedViewModel`, refactored `typesToSmoothAndDisplay` to be a reactive `StateFlow` derived directly from `measurementTypes`, automatically filtering for enabled numeric types.
- Cleaned up internal logic and improved documentation within `MeasurementSmoothingUseCases` regarding series block splitting and timestamp alignment.

* Refactor measurement smoothing and aggregation logic for improved performance and consistency.

- Removed redundant filtering of measurement types in `MeasurementSmoothingUseCases`, relying on `typesToSmoothFlow` to provide pre-filtered enabled numeric IDs.
- Optimized smoothed timestamp lookups in `MeasurementSmoothingUseCases` by using a `HashSet` for O(1) complexity.
- Updated `MeasurementAggregationUseCase` to use the minimum timestamp of a group for period calculations instead of the midpoint, ensuring more consistent boundary mapping.
- Simplified the `applySmoothing` signature in `MeasurementFacade` to match these changes.

Author: oliexdev

android_app/app/src/main/java/com/health/openscale/core/data/Enums.kt

@@ -78,6 +78,12 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import com.health.openscale.R
+import java.time.DayOfWeek
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+import java.time.temporal.WeekFields
 import java.util.Locale
 
 enum class SupportedLanguage(val code: String, val nativeDisplayName: String) {
@@ -99,7 +105,7 @@ enum class SupportedLanguage(val code: String, val nativeDisplayName: String) {
     //GALICIAN("gl", "Galician (Galego)"),
     GERMAN("de", "German (Deutsch)"),
     GREEK("el", "Greek (ελληνικά)"),
-    //HEBREW("iw", "Hebrew (עברית)"),
+    HEBREW("iw", "Hebrew (עברית)"),
     //HUNGARIAN("hu", "Hungarian (magyar)"),
     //INDONESIAN("id", "Indonesian (Bahasa Indonesia)"),
     ITALIAN("it", "Italian (Italiano)"),
@@ -458,6 +464,95 @@ enum class TimeRangeFilter(@StringRes val displayNameResId: Int) {
     }
 }
 
+enum class AggregationLevel(@StringRes val displayNameResId: Int) {
+    NONE(R.string.aggregation_level_none),
+    DAY(R.string.aggregation_level_day),
+    WEEK(R.string.aggregation_level_week),
+    MONTH(R.string.aggregation_level_month),
+    YEAR(R.string.aggregation_level_year);
+
+    fun getDisplayName(context: Context): String {
+        return context.getString(displayNameResId)
+    }
+
+
+    /**
+     * Returns the inclusive start and exclusive end of the period containing [timestamp]
+     * as epoch milliseconds.
+     *
+     * For [NONE] and [DAY] the period is a single calendar day.
+     */
+    fun periodBounds(
+        timestamp: Long,
+        zone: ZoneId = ZoneId.systemDefault(),
+    ): Pair<Long, Long> {
+        val date = Instant.ofEpochMilli(timestamp).atZone(zone).toLocalDate()
+        val (start, end) = when (this) {
+            NONE,
+            DAY   -> date to date.plusDays(1)
+            WEEK  -> { val mon = date.with(DayOfWeek.MONDAY); mon to mon.plusWeeks(1) }
+            MONTH -> { val f = date.withDayOfMonth(1); f to f.plusMonths(1) }
+            YEAR  -> { val f = date.withDayOfYear(1); f to f.plusYears(1) }
+        }
+        return start.atStartOfDay(zone).toInstant().toEpochMilli() to
+                end.atStartOfDay(zone).toInstant().toEpochMilli()
+    }
+
+    /**
+     * Returns a stable, locale-independent key for the period containing [timestamp].
+     * Suitable as a LazyColumn item key or Map key.
+     *
+     * Examples: "2025-04-07" (DAY/NONE), "2025-W15" (WEEK), "2025-4" (MONTH), "2025" (YEAR).
+     */
+    fun periodKey(
+        timestamp: Long,
+        zone: ZoneId = ZoneId.systemDefault(),
+    ): String {
+        val date = Instant.ofEpochMilli(timestamp).atZone(zone).toLocalDate()
+        return when (this) {
+            NONE,
+            DAY   -> date.toString()
+            WEEK  -> {
+                val wf = WeekFields.of(Locale.getDefault())
+                "${date.get(wf.weekBasedYear())}-W${date.get(wf.weekOfWeekBasedYear())}"
+            }
+            MONTH -> "${date.year}-${date.monthValue}"
+            YEAR  -> "${date.year}"
+        }
+    }
+
+    /**
+     * Returns a human-readable, locale-sensitive label for the period containing [timestamp].
+     *
+     * Intentionally separate from [periodKey] — labels are locale-dependent and must
+     * not be used as stable identifiers.
+     *
+     * @param calendarWeekAbbrev Localised abbreviation for "calendar week" (e.g. "CW" / "KW").
+     *                           Only used for [WEEK].
+     */
+    fun periodLabel(
+        timestamp: Long,
+        calendarWeekAbbrev: String,
+        locale: Locale = Locale.getDefault(),
+        zone: ZoneId = ZoneId.systemDefault(),
+    ): String {
+        val date = Instant.ofEpochMilli(timestamp).atZone(zone).toLocalDate()
+        return when (this) {
+            NONE,
+            DAY   -> date.format(
+                DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(locale)
+            )
+            WEEK  -> {
+                val wf = WeekFields.of(locale)
+                "${date.get(wf.weekBasedYear())} – $calendarWeekAbbrev ${date.get(wf.weekOfWeekBasedYear())}"
+            }
+            MONTH -> date.format(DateTimeFormatter.ofPattern("MMMM yyyy", locale))
+            YEAR  -> date.year.toString()
+        }
+    }
+
+}
+
 enum class SmoothingAlgorithm(@StringRes val displayNameResId: Int) {
     NONE(R.string.smoothing_algorithm_none),
     SIMPLE_MOVING_AVERAGE(R.string.smoothing_algorithm_sma),