std.Build: allow adding search methods with function and command option

This allows more granularity when adding search paths, complementing
`--search-prefix` for more specific use-cases.

## Multi-arch library layout

On systems with multilib support (e.g. Gentoo with 32-bit and 64-bit
libraries in `/usr/lib` and `/usr/lib64` respectively), using
`--search-prefix` option can cause incorrect library selected.

For example, if I want to link system `libcurl` library when building
Zig program for non-native or explicit native-compatible target,
I can try using `--search-prefix /usr`, which will automatically add:
 * `/usr/bin` as search path for binaries (fine),
 * `/usr/lib` as search path for libraries (incorrect),
 * `/usr/include` as search path for includes (fine),

In my case it will find 32-bit libraries for 64-bit target, causing
linker errors:

```console
$ zig build -Dtarget=x86_64-linux-gnu.2.35 --search-prefix /usr

error: ld.lld: /usr/lib/libcurl.so is incompatible with elf_x86_64
```

New `--search-paths` option allows to add search paths explicitly,
using passed ZON file as a specification. You can repeat multiple
times to add many different search paths if needed.

```zig
.{
    .binaries = "/usr/bin"
    .libraries = "/usr/lib64",
    .includes = "/usr/include",
}
```

## Other layouts (GCC or Android NDK etc.)

Another use-case is when binaries, libraries and includes are
distributed across different hierarchies. Suppose I want to correctly
find `gcc` binary and link `gccjit` library for my project:

```zig
.{
    .binaries = "/usr/x86_64-pc-linux-gnu/gcc-bin/14/",
    .libraries = "/usr/lib/gcc/x86_64-pc-linux-gnu/14",
    .includes = "/usr/lib/gcc/x86_64-pc-linux-gnu/14/include/",
}
```

Or use Android NDK:

```zig
.{
    // you can omit fields or set `null` if you don't want to search them.
    // .binaries = null,

    .libraries = "/path_to_ndk/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/aarch64-linux-android/35",
    .includes = "/path_to_ndk/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/include",
}
```

```zig
.{
    .libraries = "/path_to_ndk/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/aarch64-linux-android",
}
```

Signed-off-by: Eric Joldasov <bratishkaerik@landless-city.net>

Author: BratishkaErik

lib/compiler/build_runner.zig

@@ -176,6 +176,13 @@ pub fn main() !void {
             } else if (mem.eql(u8, arg, "--search-prefix")) {
                 const search_prefix = nextArgOrFatal(args, &arg_idx);
                 builder.addSearchPrefix(search_prefix);
+            } else if (mem.eql(u8, arg, "--search-paths")) {
+                const search_paths_spec = nextArgOrFatal(args, &arg_idx);
+
+                const search_paths = parseZonFile(std.Build.SearchMethod.Paths, builder, search_paths_spec) catch |err|
+                    return fatal("Unable to parse ZON file '{s}': {s}", .{ search_paths_spec, @errorName(err) });
+
+                builder.addSearchMethod(.{ .paths = search_paths });
             } else if (mem.eql(u8, arg, "--libc")) {
                 builder.libc_file = nextArgOrFatal(args, &arg_idx);
             } else if (mem.eql(u8, arg, "--color")) {
@@ -1341,6 +1348,7 @@ fn usage(b: *std.Build, out_stream: anytype) !void {
         \\  --search-prefix [path]       Add a path to look for binaries, libraries, headers
         \\  --sysroot [path]             Set the system root directory (usually /)
         \\  --libc [file]                Provide a file which specifies libc paths
+        \\  --search-paths [file]        Provide a file which specifies search paths
         \\
         \\  --system [pkgdir]            Disable package fetching; enable all integrations
         \\  -fsys=[name]                 Enable a system integration
@@ -1542,3 +1550,55 @@ fn createModuleDependenciesForStep(step: *Step) Allocator.Error!void {
         };
     }
 }
+
+/// Parse ZON file where all fields are paths relative to
+/// current working directory.
+fn parseZonFile(comptime T: type, b: *std.Build, path: []const u8) !T {
+    const spec_file = try std.fs.cwd().openFile(path, .{});
+    defer spec_file.close();
+
+    const gpa = b.allocator;
+
+    const spec = try std.zig.readSourceFileToEndAlloc(gpa, spec_file, null);
+    defer gpa.free(spec);
+
+    var ast: std.zig.Ast = try .parse(gpa, spec, .zon);
+    defer ast.deinit(gpa);
+
+    const zoir = try std.zig.ZonGen.generate(gpa, ast, .{});
+    defer zoir.deinit(gpa);
+
+    if (zoir.hasCompileErrors()) {
+        std.log.err("Can't parse ZON file '{s}: {d} errors", .{ path, zoir.compile_errors.len });
+        for (zoir.compile_errors, 1..) |compile_error, i| {
+            std.log.err("[{d}] {s}", .{ i, compile_error.msg.get(zoir) });
+            for (compile_error.getNotes(zoir)) |note| {
+                std.log.err("note: {s}", .{note.msg.get(zoir)});
+            }
+        }
+        return process.exit(1);
+    }
+
+    var result: T = .{};
+    const root_struct = switch (std.zig.Zoir.Node.Index.root.get(zoir)) {
+        .struct_literal => |struct_literal| struct_literal,
+        .empty_literal => return result,
+        else => return fatal("Can't parse ZON file '{s}': not a struct", .{path}),
+    };
+
+    for (root_struct.names, 0..) |name_i, val_i| {
+        const name = name_i.get(zoir);
+        const val = root_struct.vals.at(@intCast(val_i)).get(zoir);
+
+        inline for (@typeInfo(T).@"struct".fields) |field| {
+            if (std.mem.eql(u8, name, field.name)) {
+                const string = switch (val) {
+                    .string_literal => |string_literal| string_literal,
+                    else => return fatal("Can't parse field '{s}' in ZON file '{s}': not a string", .{ field.name, path }),
+                };
+                @field(result, field.name) = .{ .cwd_relative = b.dupePath(string) };
+            }
+        }
+    }
+    return result;
+}

lib/std/Build.zig

@@ -2133,9 +2133,13 @@ pub const SearchMethod = union(enum) {
 };
 
 pub fn addSearchPrefix(b: *Build, search_prefix: []const u8) void {
-    b.search_methods.append(b.allocator, .{
+    b.addSearchMethod(.{
         .prefix = .{ .cwd_relative = b.dupePath(search_prefix) },
-    }) catch @panic("OOM");
+    });
+}
+
+pub fn addSearchMethod(b: *Build, search_method: SearchMethod) void {
+    b.search_methods.append(b.allocator, search_method) catch @panic("OOM");
 }
 
 pub fn getInstallPath(b: *Build, dir: InstallDir, dest_rel_path: []const u8) []const u8 {