all: move standalone libraries to libs/ subdirectory

The root dir of our repository has grown quite a lot the past few months.

I'd like to make it more clear where the bulk of the engine lives (`src/`) and
also make it more clear which Mach libraries are consumable as standalone projects.

As for the name of this directory, `libs` was my first choice but there's a bit of
a convention of that being external libraries in Zig projects _today_, while these
are libraries maintained as part of Mach in this repository - not external ones.

We will name this directory `libs`, and if we have a need for external libraries
we will use `external` or `deps` for that directory name. I considered other names
such as `components`, `systems`, `modules` (which are bad as they overlap with
major ECS / engine concepts), and it seems likely the official Zig package manager
will break the convention of using a `libs` dir anyway.

Performed via:

```sh
mkdir libs/
git mv freetype libs/
git mv basisu libs/
git mv gamemode libs/
git mv glfw libs/
git mv gpu libs/
git mv gpu-dawn libs/
git mv sysaudio libs/
git mv sysjs libs/
git mv ecs libs/
```

git-subtree-dir: glfw
git-subtree-mainline: 0d5b853443
git-subtree-split: 572d1144f11b353abdb64fff828b25a4f0fbb7ca

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

git mv ecs libs/

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

libs/gpu/src/bind_group_layout.zig

@@ -0,0 +1,130 @@
+const ChainedStruct = @import("types.zig").ChainedStruct;
+const ShaderStageFlags = @import("types.zig").ShaderStageFlags;
+const Buffer = @import("buffer.zig").Buffer;
+const Sampler = @import("sampler.zig").Sampler;
+const Texture = @import("texture.zig").Texture;
+const TextureView = @import("texture_view.zig").TextureView;
+const StorageTextureBindingLayout = @import("types.zig").StorageTextureBindingLayout;
+const StorageTextureAccess = @import("types.zig").StorageTextureAccess;
+const ExternalTexture = @import("external_texture.zig").ExternalTexture;
+const Impl = @import("interface.zig").Impl;
+
+pub const BindGroupLayout = opaque {
+    pub const Entry = extern struct {
+        pub const NextInChain = extern union {
+            generic: ?*const ChainedStruct,
+            external_texture_binding_layout: *const ExternalTexture.BindingLayout,
+        };
+
+        next_in_chain: NextInChain = .{ .generic = null },
+        binding: u32,
+        visibility: ShaderStageFlags,
+        buffer: Buffer.BindingLayout = .{},
+        sampler: Sampler.BindingLayout = .{},
+        texture: Texture.BindingLayout = .{},
+        storage_texture: StorageTextureBindingLayout = .{},
+
+        /// Helper to create a buffer BindGroupLayout.Entry.
+        pub fn buffer(
+            binding: u32,
+            visibility: ShaderStageFlags,
+            binding_type: Buffer.BindingType,
+            has_dynamic_offset: bool,
+            min_binding_size: u64,
+        ) Entry {
+            return .{
+                .binding = binding,
+                .visibility = visibility,
+                .buffer = .{
+                    .type = binding_type,
+                    .has_dynamic_offset = has_dynamic_offset,
+                    .min_binding_size = min_binding_size,
+                },
+            };
+        }
+
+        /// Helper to create a sampler BindGroupLayout.Entry.
+        pub fn sampler(
+            binding: u32,
+            visibility: ShaderStageFlags,
+            binding_type: Sampler.BindingType,
+        ) Entry {
+            return .{
+                .binding = binding,
+                .visibility = visibility,
+                .sampler = .{ .type = binding_type },
+            };
+        }
+
+        /// Helper to create a texture BindGroupLayout.Entry.
+        pub fn texture(
+            binding: u32,
+            visibility: ShaderStageFlags,
+            sample_type: Texture.SampleType,
+            view_dimension: TextureView.Dimension,
+            multisampled: bool,
+        ) Entry {
+            return .{
+                .binding = binding,
+                .visibility = visibility,
+                .texture = .{
+                    .sample_type = sample_type,
+                    .view_dimension = view_dimension,
+                    .multisampled = multisampled,
+                },
+            };
+        }
+
+        /// Helper to create a storage texture BindGroupLayout.Entry.
+        pub fn storageTexture(
+            binding: u32,
+            visibility: ShaderStageFlags,
+            access: StorageTextureAccess,
+            format: Texture.Format,
+            view_dimension: TextureView.Dimension,
+        ) Entry {
+            return .{
+                .binding = binding,
+                .visibility = visibility,
+                .storage_texture = .{
+                    .access = access,
+                    .format = format,
+                    .view_dimension = view_dimension,
+                },
+            };
+        }
+    };
+
+    pub const Descriptor = extern struct {
+        next_in_chain: ?*const ChainedStruct = null,
+        label: ?[*:0]const u8 = null,
+        entry_count: u32 = 0,
+        entries: ?[*]const Entry = null,
+
+        /// Provides a slightly friendlier Zig API to initialize this structure.
+        pub inline fn init(v: struct {
+            next_in_chain: ?*const ChainedStruct = null,
+            label: ?[*:0]const u8 = null,
+            entries: ?[]const Entry = null,
+        }) Descriptor {
+            return .{
+                .next_in_chain = v.next_in_chain,
+                .label = v.label,
+                .entry_count = if (v.entries) |e| @intCast(u32, e.len) else 0,
+                .entries = if (v.entries) |e| e.ptr else null,
+            };
+        }
+    };
+
+    pub inline fn setLabel(bind_group_layout: *BindGroupLayout, label: [*:0]const u8) void {
+        Impl.bindGroupLayoutSetLabel(bind_group_layout, label);
+    }
+
+    pub inline fn reference(bind_group_layout: *BindGroupLayout) void {
+        Impl.bindGroupLayoutReference(bind_group_layout);
+    }
+
+    pub inline fn release(bind_group_layout: *BindGroupLayout) void {
+        Impl.bindGroupLayoutRelease(bind_group_layout);
+    }
+};