Account for clippy-driver having extra prefix rustc

I noticed that we were not caching clippy calls:

```
parse_arguments: CannotCache(multiple input files): ["rustc", "--crate-name", "bots_utils", "--edition=2024", ...
```

Turns out `rustc` is interpreted as one of the source inputs, so the actual
input trips sccache into thinking that there are multiple inputs, which is
not supported, so the caching does not happen.

In a workspace with 161 members and 1761 total crates in the dependency graph
we see the following results with sccache running hot (no misses):

* Before:

```
Finished `dev` profile [unoptimized + debuginfo] target(s) in 1m 24s
```

```
Compile requests                    1802
Compile requests executed           1182
Cache hits                          1177
Cache hits (C/C++)                   107
Cache hits (Rust)                   1070
Cache misses                           0
Cache hits rate                   100.00 %
Cache hits rate (C/C++)           100.00 %
Cache hits rate (Rust)            100.00 %
Cache timeouts                         0
Cache read errors                      0
Forced recaches                        0
Cache write errors                     0
Cache errors                           0
Compilations                           0
Compilation failures                   5
Non-cacheable compilations             0
Non-cacheable calls                  610
Non-compilation calls                 10
Unsupported compiler calls             0
Average cache write                0.000 s
Average compiler                   0.000 s
Average cache read hit             0.000 s
Failed distributed compilations        0

Non-cacheable reasons:
multiple input files                 339
crate-type                           222
unknown source language               23
-                                     12
missing input                          8
-o                                     3
missing output_dir                     3

Cache location                  Local disk: "/home/ivan/.cache/sccache"
Use direct/preprocessor mode?   yes
Version (client)                0.9.1
Cache size                           444 MiB
Max cache size                        10 GiB
```

* After:

```
Finished `dev` profile [unoptimized + debuginfo] target(s) in 1m 11s
```

```
Compile requests                    1799
Compile requests executed           1332
Cache hits                          1327
Cache hits (C/C++)                   107
Cache hits (Rust)                   1220
Cache misses                           0
Cache hits rate                   100.00 %
Cache hits rate (C/C++)           100.00 %
Cache hits rate (Rust)            100.00 %
Cache timeouts                         0
Cache read errors                      0
Forced recaches                        0
Cache write errors                     0
Cache errors                           0
Compilations                           0
Compilation failures                   5
Non-cacheable compilations             0
Non-cacheable calls                  457
Non-compilation calls                 10
Unsupported compiler calls             0
Average cache write                0.000 s
Average compiler                   0.000 s
Average cache read hit             0.000 s
Failed distributed compilations        0

Non-cacheable reasons:
crate-type                           407
unknown source language               23
-                                     11
missing input                          9
argument parse                         4
-o                                     3

Cache location                  Local disk: "/home/ivan/.cache/sccache"
Use direct/preprocessor mode?   yes
Version (client)                0.10.0
Cache size                           444 MiB
Max cache size                        10 GiB
```

Author: bobrik

src/compiler/rust.rs

@@ -1084,7 +1084,7 @@ fn parse_arguments(arguments: &[OsString], cwd: &Path) -> CompilerArguments<Pars
     let mut gcno = false;
     let mut target_json = None;
 
-    for arg in ArgsIter::new(arguments.iter().cloned(), &ARGS[..]) {
+    for (idx, arg) in ArgsIter::new(arguments.iter().cloned(), &ARGS[..]).enumerate() {
         let arg = try_or_cannot_cache!(arg, "argument parse");
         match arg.get_data() {
             Some(TooHardFlag) | Some(TooHardPath(_)) => {
@@ -1176,9 +1176,21 @@ fn parse_arguments(arguments: &[OsString], cwd: &Path) -> CompilerArguments<Pars
             None => {
                 match arg {
                     Argument::Raw(ref val) => {
+                        if idx == 0 {
+                            if let Some(value) = val.to_str() {
+                                if value == "rustc" {
+                                    // If the first argument is rustc, it's likely called via clippy-driver,
+                                    // so it's not actually an input file, which means we should discount it.
+                                    continue;
+                                }
+                            }
+                        }
                         if input.is_some() {
                             // Can't cache compilations with multiple inputs.
-                            cannot_cache!("multiple input files");
+                            cannot_cache!(
+                                "multiple input files",
+                                format!("prev = {input:?}, next = {arg:?}")
+                            );
                         }
                         input = Some(val.clone());
                     }