logiguard fork: GPUI xdg-activation keyboard-focus serial fix

Single-commit orphan branch: full zed-industries/zed @ 8c74db0 source tree
with a 3-file patch applied (no upstream history).

Patch (crates/gpui_linux/src/linux/wayland/):
  - serial.rs: add SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; add latest_serial_of()
  - window.rs: activate() uses keyboard-enter serial (Mutter focus gate)

Mutter honors window activation only when the token carries the keyboard-
focus serial from wl_keyboard.enter; GPUI used a stale mouse-press serial.
See docs/tray-window-focus-wayland.md in logiguard.

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

crates/collab/src/db/queries/shared_threads.rs

@@ -0,0 +1,77 @@
+use chrono::Utc;
+
+use super::*;
+use crate::db::tables::shared_thread;
+
+impl Database {
+    pub async fn upsert_shared_thread(
+        &self,
+        id: SharedThreadId,
+        user_id: UserId,
+        title: &str,
+        data: Vec<u8>,
+    ) -> Result<()> {
+        let title = title.to_string();
+        self.transaction(|tx| {
+            let title = title.clone();
+            let data = data.clone();
+            async move {
+                let now = Utc::now().naive_utc();
+
+                let existing = shared_thread::Entity::find_by_id(id).one(&*tx).await?;
+
+                match existing {
+                    Some(existing) => {
+                        if existing.user_id != user_id {
+                            Err(anyhow!("Cannot update shared thread owned by another user"))?;
+                        }
+
+                        let mut active: shared_thread::ActiveModel = existing.into();
+                        active.title = ActiveValue::Set(title);
+                        active.data = ActiveValue::Set(data);
+                        active.updated_at = ActiveValue::Set(now);
+                        active.update(&*tx).await?;
+                    }
+                    None => {
+                        shared_thread::ActiveModel {
+                            id: ActiveValue::Set(id),
+                            user_id: ActiveValue::Set(user_id),
+                            title: ActiveValue::Set(title),
+                            data: ActiveValue::Set(data),
+                            created_at: ActiveValue::Set(now),
+                            updated_at: ActiveValue::Set(now),
+                        }
+                        .insert(&*tx)
+                        .await?;
+                    }
+                }
+
+                Ok(())
+            }
+        })
+        .await
+    }
+
+    pub async fn get_shared_thread(
+        &self,
+        share_id: SharedThreadId,
+    ) -> Result<Option<(shared_thread::Model, String)>> {
+        self.transaction(|tx| async move {
+            let Some(thread) = shared_thread::Entity::find_by_id(share_id)
+                .one(&*tx)
+                .await?
+            else {
+                return Ok(None);
+            };
+
+            let user = user::Entity::find_by_id(thread.user_id).one(&*tx).await?;
+
+            let username = user
+                .map(|u| u.github_login)
+                .unwrap_or_else(|| "Unknown".to_string());
+
+            Ok(Some((thread, username)))
+        })
+        .await
+    }
+}