feat(nexus): production modular HTTP/1.1 server + compiler fixes

- Rewrite apps/nexus with modular architecture:
  Config, Http, Errors, Parser, Router, Handlers, Server, Main
- Use algebraic enums for ParseResult/FileResult/HttpError
- Thread-pool server via Channel<ConnectionTask> and spawn
- Fix C backend type ordering for generic struct instances
  (Array_T, Iter_T) and algebraic enum struct payloads
- Collect Slice_T types from struct fields and enum payloads
- Fix match lowering for simple enums (direct value compare)
- Resolve match expression return type from first arm
- Infer element type for for-in over Array<UserStruct>
- Preserve generic type args in field access resolution
- Add fflush to PrintLine/Print for immediate server logs
- Add modern_features golden regression test
- Regenerate golden expected.c files

apps/nexus/src/Errors.bux

@@ -0,0 +1,65 @@
+module Errors {
+
+import Http::{HttpRequest};
+
+pub enum HttpError {
+    BadRequest,
+    NotFound,
+    MethodNotAllowed,
+    InternalError(String),
+}
+
+pub enum ParseResult {
+    Ok(HttpRequest),
+    Err(HttpError),
+}
+
+pub enum FileResult {
+    Ok(String),
+    Err(HttpError),
+}
+
+pub func ParseResult_NewOk(req: HttpRequest) -> ParseResult {
+    let r: ParseResult = ParseResult { tag: ParseResult_Ok };
+    r.data.Ok_0 = req;
+    return r;
+}
+
+pub func ParseResult_NewErr(err: HttpError) -> ParseResult {
+    let r: ParseResult = ParseResult { tag: ParseResult_Err };
+    r.data.Err_0 = err;
+    return r;
+}
+
+pub func FileResult_NewOk(content: String) -> FileResult {
+    let r: FileResult = FileResult { tag: FileResult_Ok };
+    r.data.Ok_0 = content;
+    return r;
+}
+
+pub func FileResult_NewErr(err: HttpError) -> FileResult {
+    let r: FileResult = FileResult { tag: FileResult_Err };
+    r.data.Err_0 = err;
+    return r;
+}
+
+pub func FileResult_IsOk(r: FileResult) -> bool {
+    return r.tag == FileResult_Ok;
+}
+
+pub func FileResult_Unwrap(r: FileResult) -> String {
+    return r.data.Ok_0;
+}
+
+pub func FileResult_UnwrapErr(r: FileResult) -> HttpError {
+    return r.data.Err_0;
+}
+
+pub func HttpError_ToString(err: HttpError) -> String {
+    if err.tag == HttpError_BadRequest       { return "Bad Request"; }
+    if err.tag == HttpError_NotFound         { return "Not Found"; }
+    if err.tag == HttpError_MethodNotAllowed { return "Method Not Allowed"; }
+    return err.data.InternalError_0;
+}
+
+}