feat: add extern fn declarations for JS FFI

Adds `extern fn` syntax for declaring external JavaScript functions:
  extern fn getElementById(id: String): Element
  extern fn getContext(el: Element, kind: String): CanvasCtx = "getContext"
  pub extern fn alert(msg: String): Unit

Changes across 11 files:
- Lexer: `extern` keyword
- AST: `ExternFnDecl` struct + `Declaration::ExternFn` variant
- Parser: parse `extern fn` with optional `= "jsName"` override
- Typechecker: register extern fn type signatures
- Interpreter: ExternFn value with clear error on call
- JS backend: emit extern fn calls using JS name (no _lux suffix)
- C backend: silently skips extern fns
- Formatter, linter, modules, symbol_table: handle new variant

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/parser.rs

@@ -238,6 +238,7 @@ impl Parser {
 
         match self.peek_kind() {
             TokenKind::Fn => Ok(Declaration::Function(self.parse_function_decl(visibility, doc)?)),
+            TokenKind::Extern => Ok(Declaration::ExternFn(self.parse_extern_fn_decl(visibility, doc)?)),
             TokenKind::Effect => Ok(Declaration::Effect(self.parse_effect_decl(doc)?)),
             TokenKind::Handler => Ok(Declaration::Handler(self.parse_handler_decl()?)),
             TokenKind::Type => Ok(Declaration::Type(self.parse_type_decl(visibility, doc)?)),
@@ -246,7 +247,7 @@ impl Parser {
             TokenKind::Impl => Ok(Declaration::Impl(self.parse_impl_decl()?)),
             TokenKind::Run => Err(self.error("Bare 'run' expressions are not allowed at top level. Use 'let _ = run ...' or 'let result = run ...'")),
             TokenKind::Handle => Err(self.error("Bare 'handle' expressions are not allowed at top level. Use 'let _ = handle ...' or 'let result = handle ...'")),
-            _ => Err(self.error("Expected declaration (fn, effect, handler, type, trait, impl, or let)")),
+            _ => Err(self.error("Expected declaration (fn, extern, effect, handler, type, trait, impl, or let)")),
         }
     }
 
@@ -323,6 +324,57 @@ impl Parser {
         })
     }
 
+    /// Parse extern function declaration: extern fn name<T>(params): ReturnType = "jsName"
+    fn parse_extern_fn_decl(&mut self, visibility: Visibility, doc: Option<String>) -> Result<ExternFnDecl, ParseError> {
+        let start = self.current_span();
+        self.expect(TokenKind::Extern)?;
+        self.expect(TokenKind::Fn)?;
+
+        let name = self.parse_ident()?;
+
+        // Optional type parameters
+        let type_params = if self.check(TokenKind::Lt) {
+            self.parse_type_params()?
+        } else {
+            Vec::new()
+        };
+
+        self.expect(TokenKind::LParen)?;
+        let params = self.parse_params()?;
+        self.expect(TokenKind::RParen)?;
+
+        // Return type
+        self.expect(TokenKind::Colon)?;
+        let return_type = self.parse_type()?;
+
+        // Optional JS name override: = "jsName"
+        let js_name = if self.check(TokenKind::Eq) {
+            self.advance();
+            match self.peek_kind() {
+                TokenKind::String(s) => {
+                    let name = s.clone();
+                    self.advance();
+                    Some(name)
+                }
+                _ => return Err(self.error("Expected string literal for JS name in extern fn")),
+            }
+        } else {
+            None
+        };
+
+        let span = start.merge(self.previous_span());
+        Ok(ExternFnDecl {
+            visibility,
+            doc,
+            name,
+            type_params,
+            params,
+            return_type,
+            js_name,
+            span,
+        })
+    }
+
     /// Parse effect declaration
     fn parse_effect_decl(&mut self, doc: Option<String>) -> Result<EffectDecl, ParseError> {
         let start = self.current_span();