refactor: implement ActivityManager (#1016)

## Summary

Ref comment:
https://github.com/crosspoint-reader/crosspoint-reader/pull/1010#pullrequestreview-3828854640

This PR introduces `ActivityManager`, which mirrors the same concept of
Activity in Android, where an activity represents a single screen of the
UI. The manager is responsible for launching activities, and ensuring
that only one activity is active at a time.

Main differences from Android's ActivityManager:
- No concept of Bundle or Intent extras
- No onPause/onResume, since we don't have a concept of background
activities
- onActivityResult is implemented via a callback instead of a separate
method, for simplicity

## Key changes

- Single `renderTask` shared across all activities
- No more sub-activity, we manage them using a stack; Results can be
passed via `startActivityForResult` and `setResult`
- Activity can call `finish()` to destroy themself, but the actual
deletion will be handled by `ActivityManager` to avoid `delete this`
pattern

As a bonus: the manager will automatically call `requestUpdate()` when
returning from another activity

## Example usage

**BEFORE**:

```cpp
// caller
    enterNewActivity(new WifiSelectionActivity(renderer, mappedInput,
                                               [this](const bool connected) { onWifiSelectionComplete(connected); }));

// subactivity
  onComplete(true); // will eventually call exitActivity(), which deletes the caller instance (dangerous behavior)
``` 

**AFTER**: (mirrors the `startActivityForResult` and `setResult` from
android)

```cpp
// caller
  startActivityForResult(new NetworkModeSelectionActivity(renderer, mappedInput),
                         [this](const ActivityResult& result) { onNetworkModeSelected(result.selectedNetworkMode); });

// subactivity
  ActivityResult result;
  result.isCancelled = false;
  result.selectedNetworkMode = mode;
  setResult(result);
  finish(); // signals to ActivityManager to go back to last activity AFTER this function returns
```

TODO:
- [x] Reconsider if the `Intent` is really necessary or it should be
removed (note: it's inspired by
[Intent](https://developer.android.com/guide/components/intents-common)
from Android API) ==> I decided to keep this pattern fr clarity
- [x] Verify if behavior is still correct (i.e. back from sub-activity)
- [x] Refactor the `ActivityWithSubactivity` to just simple `Activity`
--> We are using a stack for keeping track of sub-activity now
- [x] Use single task for rendering --> avoid allocating 8KB stack per
activity
- [x] Implement the idea of [Activity
result](https://developer.android.com/training/basics/intents/result)
--> Allow sub-activity like Wifi to report back the status (connected,
failed, etc)

---

### AI Usage

While CrossPoint doesn't have restrictions on AI tools in contributing,
please be transparent about their usage as it
helps set the right context for reviewers.

Did you use AI tools to help write this code? **PARTIALLY**, some
repetitive migrations are done by Claude, but I'm the one how ultimately
approve it

---------

Co-authored-by: Zach Nelson <zach@zdnelson.com>

src/activities/ActivityManager.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <cassert>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "GfxRenderer.h"
+#include "MappedInputManager.h"
+#include "RenderLock.h"
+
+class Activity;    // forward declaration
+class RenderLock;  // forward declaration
+
+/**
+ * ActivityManager
+ *
+ * This mirrors the same concept of Activity in Android, where an activity represents a single screen of the UI. The
+ * manager is responsible for launching activities, and ensuring that only one activity is active at a time.
+ *
+ * It also provides a stack mechanism to allow activities to launch sub-activities and get back the results when the
+ * sub-activity is done. For example, the WebServer activity can launch a WifiSelect activity to let the user choose a
+ * wifi network, and get back the selected network when the user is done.
+ *
+ * Main differences from Android's ActivityManager:
+ * - No onPause/onResume, since we don't have a concept of background activities
+ * - onActivityResult is implemented via a callback instead of a separate method, for simplicity
+ */
+class ActivityManager {
+ protected:
+  GfxRenderer& renderer;
+  MappedInputManager& mappedInput;
+  std::vector<std::unique_ptr<Activity>> stackActivities;
+  std::unique_ptr<Activity> currentActivity;
+
+  void exitActivity(const RenderLock& lock);
+
+  // Pending activity to be launched on next loop iteration
+  std::unique_ptr<Activity> pendingActivity;
+  enum class PendingAction { None, Push, Pop, Replace };
+  PendingAction pendingAction = PendingAction::None;
+
+  // Task to render and display the activity
+  TaskHandle_t renderTaskHandle = nullptr;
+  static void renderTaskTrampoline(void* param);
+  [[noreturn]] virtual void renderTaskLoop();
+
+  // Whether to trigger a render after the current loop()
+  // This variable must only be set by the main loop, to avoid race conditions
+  bool requestedUpdate = false;
+
+ public:
+  explicit ActivityManager(GfxRenderer& renderer, MappedInputManager& mappedInput)
+      : renderer(renderer), mappedInput(mappedInput), renderingMutex(xSemaphoreCreateMutex()) {
+    assert(renderingMutex != nullptr && "Failed to create rendering mutex");
+    stackActivities.reserve(10);
+  }
+  ~ActivityManager() { assert(false); /* should never be called */ };
+
+  // Mutex to protect rendering operations from race conditions
+  // Must only be used via RenderLock
+  SemaphoreHandle_t renderingMutex = nullptr;
+
+  void begin();
+  void loop();
+
+  // Will replace currentActivity and drop all activities on stack
+  void replaceActivity(std::unique_ptr<Activity>&& newActivity);
+
+  // goTo... functions are convenient wrapper for replaceActivity()
+  void goToFileTransfer();
+  void goToSettings();
+  void goToMyLibrary(std::string path = {});
+  void goToRecentBooks();
+  void goToBrowser();
+  void goToReader(std::string path);
+  void goToSleep();
+  void goToBoot();
+  void goToFullScreenMessage(std::string message, EpdFontFamily::Style style = EpdFontFamily::REGULAR);
+  void goHome();
+
+  // This will move current activity to stack instead of deleting it
+  void pushActivity(std::unique_ptr<Activity>&& activity);
+
+  // Remove the currentActivity, returning the last one on stack
+  // Note: if popActivity() on last activity on the stack, we will goHome()
+  void popActivity();
+
+  bool preventAutoSleep() const;
+  bool isReaderActivity() const;
+  bool skipLoopDelay() const;
+
+  // If immediate is true, the update will be triggered immediately.
+  // Otherwise, it will be deferred until the end of the current loop iteration.
+  void requestUpdate(bool immediate = false);
+};
+
+extern ActivityManager activityManager;  // singleton, to be defined in main.cpp