feat: implement Phase 1 — manifest, codegen pipeline, ABI types, and tests

Implement the complete atsiser Phase 1 pipeline for wrapping C codebases
in ATS2 linear types with zero-cost memory safety:

Manifest (src/manifest/mod.rs):
- [project], [[c-sources]] (path, include-dirs), [[ownership-rules]]
  (function, pattern: alloc/free/borrow/transfer), [ats2] (compiler flags)
- Validation, init template generation, info display

Codegen pipeline (src/codegen/):
- parser.rs: regex-based C header parser extracting function signatures
  with heuristic alloc/free/borrow pattern detection
- ats_gen.rs: generates ATS2 viewtype wrappers (.sats/.dats) from parsed
  C signatures and ownership rules, with proof obligations
- compiler.rs: constructs patsopt/patscc commands for ATS2 compilation

ABI types (src/abi/mod.rs):
- OwnershipPattern, Viewtype (standard/nullable/sized), LinearPtr,
  MemorySafetyProof (alloc/free/borrow/bounds/null-check), ATSModule,
  ATSFunction, ATSParam — with ATS2 source generation

Tests: 32 unit tests + 12 integration tests covering manifest round-trip,
C header parsing, ownership detection, module generation, code rendering,
compiler commands, and end-to-end file generation.

Example: examples/safe-malloc/ with stdlib_subset.h and atsiser.toml.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

Cargo.lock

@@ -18,6 +18,7 @@ anyhow = "1"
 thiserror = "2"
 handlebars = "6"
 walkdir = "2"
+regex = "1"
 
 [dev-dependencies]
 tempfile = "3"

Cargo.toml

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# atsiser example: safe-malloc
+#
+# Wraps standard C memory allocation (malloc/free/realloc) with ATS2 linear
+# types. After wrapping, the ATS2 type-checker guarantees:
+# - Every malloc'd pointer is freed exactly once
+# - No use-after-free (the linear type is consumed by free)
+# - No double-free (the linear type can only be consumed once)
+# - Borrows (e.g., memcpy, strlen) do not consume the resource
+
+[project]
+name = "safe-malloc"
+version = "0.1.0"
+description = "ATS2 linear type wrappers for malloc/free/realloc"
+output-dir = "generated/ats"
+
+[[c-sources]]
+path = "include/stdlib_subset.h"
+include-dirs = ["include"]
+description = "Subset of stdlib.h with memory allocation functions"
+
+[[ownership-rules]]
+function = "malloc"
+pattern = "alloc"
+resource-type = "void"
+description = "Allocates size bytes; returns pointer that must be freed"
+
+[[ownership-rules]]
+function = "free"
+pattern = "free"
+param-index = 0
+resource-type = "void"
+description = "Deallocates a malloc'd pointer"
+
+[[ownership-rules]]
+function = "realloc"
+pattern = "transfer"
+param-index = 0
+resource-type = "void"
+description = "Transfers ownership: old pointer consumed, new pointer returned"
+
+[[ownership-rules]]
+function = "memcpy"
+pattern = "borrow"
+param-index = 0
+description = "Borrows dest and src pointers for copying"
+
+[ats2]
+patsopt = "patsopt"
+patscc = "patscc"
+flags = ["-DATS_MEMALLOC_LIBC"]
+c-flags = ["-O2", "-Wall"]

examples/safe-malloc/atsiser.toml

@@ -0,0 +1,28 @@
+/* SPDX-License-Identifier: PMPL-1.0-or-later */
+/* Subset of stdlib.h for atsiser safe-malloc example.
+ *
+ * These are the standard C memory allocation functions that atsiser wraps
+ * with ATS2 linear types to provide compile-time memory safety guarantees.
+ */
+
+#ifndef STDLIB_SUBSET_H
+#define STDLIB_SUBSET_H
+
+#include <stddef.h>
+
+/* Allocate SIZE bytes of memory. Returns a pointer that MUST be freed. */
+void* malloc(size_t size);
+
+/* Free a block allocated by malloc/realloc. Pointer MUST NOT be used after. */
+void free(void* ptr);
+
+/* Re-allocate a block to NEW_SIZE bytes. Old pointer is CONSUMED. */
+void* realloc(void* ptr, size_t new_size);
+
+/* Copy N bytes from SRC to DEST. Both pointers are BORROWED (not consumed). */
+void* memcpy(void* dest, const void* src, size_t n);
+
+/* Set N bytes of DEST to VALUE. Pointer is BORROWED. */
+void* memset(void* dest, int value, size_t n);
+
+#endif /* STDLIB_SUBSET_H */