Allow filling co-authors in the git panel's commit input (#23329)

https://github.com/user-attachments/assets/78db908e-cfe5-4803-b0dc-4f33bc457840


* starts to extract usernames out of `users/` GitHub API responses, and
pass those along with e-mails in the collab sessions as part of the
`User` data

* adjusts various prefill and seed test methods so that the new data can
be retrieved from GitHub properly

* if there's an active call, where guests have write permissions and
e-mails, allow to trigger `FillCoAuthors` action in the context of the
git panel, that will fill in `co-authored-by:` lines, using e-mail and
names (or GitHub handle names if name is absent)

* the action tries to not duplicate such entries, if any are present
already, and adds those below the rest of the commit input's text

Concerns:

* users with write permissions and no e-mails will be silently omitted
— adding odd entries that try to indicate this or raising pop-ups is
very intrusive (maybe, we can add `#`-prefixed comments?), logging seems
pointless

* it's not clear whether the data prefill will run properly on the
existing users — seems tolerable now, as it seems that we get e-mails
properly already, so we'll see GitHub handles instead of names in the
worst case. This can be prefilled better later.

* e-mails and names for a particular project may be not what the user
wants.
E.g. my `.gitconfig` has
```
[user]
    email = mail4score@gmail.com

# .....snip

[includeif "gitdir:**/work/zed/**/.git"]
    path = ~/.gitconfig.work
```

and that one has

```
[user]
    email = kirill@zed.dev
```

while my GitHub profile is configured so, that `mail4score@gmail.com` is
the public, commit e-mail.

So, when I'm a participant in a Zed session, wrong e-mail will be
picked.
The problem is, it's impossible for a host to get remote's collaborator
git metadata for a particular project, as that might not even exist on
disk for the client.

Seems that we might want to add some "project git URL <-> user name and
email" mapping in the settings(?).
The design of this is not very clear, so the PR concentrates on the
basics for now.

When https://github.com/zed-industries/zed/pull/23308 lands, most of the
issues can be solved by collaborators manually, before committing.

Release Notes:

- N/A

crates/collab/src/seed.rs

@@ -16,6 +16,7 @@ struct GithubUser {
     id: i32,
     login: String,
     email: Option<String>,
+    name: Option<String>,
     created_at: DateTime<Utc>,
 }
 
@@ -75,6 +76,7 @@ pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result
         let user = db
             .create_user(
                 &user.email.unwrap_or(format!("{admin_login}@example.com")),
+                user.name.as_deref(),
                 true,
                 NewUserParams {
                     github_login: user.login,
@@ -129,6 +131,7 @@ pub async fn seed(config: &Config, db: &Database, force: bool) -> anyhow::Result
                 &github_user.login,
                 github_user.id,
                 github_user.email.as_deref(),
+                github_user.name.as_deref(),
                 github_user.created_at,
                 None,
             )
@@ -152,14 +155,20 @@ fn load_admins(path: impl AsRef<Path>) -> anyhow::Result<SeedConfig> {
 }
 
 async fn fetch_github<T: DeserializeOwned>(client: &reqwest::Client, url: &str) -> T {
-    let response = client
-        .get(url)
+    let mut request_builder = client.get(url);
+    if let Ok(github_token) = std::env::var("GITHUB_TOKEN") {
+        request_builder =
+            request_builder.header("Authorization", format!("Bearer {}", github_token));
+    }
+    let response = request_builder
         .header("user-agent", "zed")
         .send()
         .await
         .unwrap_or_else(|error| panic!("failed to fetch '{url}': {error}"));
-    response
-        .json()
-        .await
-        .unwrap_or_else(|error| panic!("failed to deserialize github user from '{url}': {error}"))
+    let response_text = response.text().await.unwrap_or_else(|error| {
+        panic!("failed to fetch '{url}': {error}");
+    });
+    serde_json::from_str(&response_text).unwrap_or_else(|error| {
+        panic!("failed to deserialize github user from '{url}'. Error: '{error}', text: '{response_text}'");
+    })
 }