Fix #73: automatic compile-time lifetime safety via proc macro

[mazong1123]

Summary

Fixes #73 by automatically detecting lifetime mismatches in func! at compile time using a proc macro — no user code changes required.

Problem

Rust's function pointer subtyping allows fn(&str) -> &'static str to be silently coerced to fn(&str) -> &str. When func! and fake! use the wrong type, the fake can return a dangling reference — undefined behavior with no compiler warning.

How it works

The func! macro's simplified fn syntax now delegates to a proc macro (injectorpp-macros) that inspects the return type:

• Bare reference returns (e.g., -> &str, -> &[u8]): an invariance-based check is generated that detects if the function's actual return lifetime differs from the specified type
• Explicit lifetime returns (e.g., -> &'static str, -> &'_ str): no check needed — the user has stated their intent
• Non-reference returns (e.g., -> i32, -> Option<&str>): no check needed

Example: issue #73 is now caught at compile time

fn foo(_s: &str) -> &'static str { "hello" }

// This now produces a compile error instead of silent UB:
let f = func!(fn (foo)(&str) -> &str);  // ERROR: mismatched types
// Fix: specify the correct lifetime
let f = func!(fn (foo)(&str) -> &'static str);  // OK

For linked-lifetime functions

Functions that genuinely return references linked to input lifetimes can add an explicit annotation:

fn baz(s: &str) -> &str { s }
let f = func!(fn (baz)(&str) -> &'_ str);  // OK

Architecture

• injectorpp-macros/: new proc macro crate with func_checked
• func!: Case 1 (generic) and Case 2 (explicit type) remain as declarative macros; simplified fn syntax delegates to the proc macro via catch-all arm
• Same user interface: func! syntax is completely unchanged — existing code compiles without modification

Testing

131 tests pass (100 unit/integration + 31 doctests). Clippy clean.

10 new lifetime safety tests (tests/lifetime_safety.rs):

Test	Type	Scenario
static_str_coerced_to_bare_ref	compile-fail	&'static str coerced to &str return
static_slice_coerced_to_bare_ref	compile-fail	&'static [u8] coerced to &[u8] return
func_info_prefix_lifetime_mismatch	compile-fail	Same issue with func_info: prefix syntax
fake_returns_dangling_reference	compile-fail	Full func! + fake! + will_execute pattern from issue #73
pass_explicit_static_lifetime	pass	-> &'static str is accepted
pass_explicit_elided_lifetime	pass	-> &'_ str is accepted
pass_non_reference_return	pass	-> i32 is accepted
pass_wrapped_reference_return	pass	-> Option<&str> is accepted
pass_unit_return	pass	No return type is accepted
pass_case2_explicit_type	pass	Case 2 explicit type syntax is accepted

Compile-fail tests use direct rustc invocation (exit code only, no stderr matching) to avoid fragility across Rust versions.

Closes #73