More refactoring of tests and packages

Squashed commit of the following:

commit c4659d8be4d664ba7fd4b59d613536f2368cff0e
Author: riton <riton@riton.home>
Date:   Mon Jul 14 21:44:48 2025 +0300

    fix package name typo

commit ec802339b838d059f4bc9e4da7cc370ab4d91a46
Author: riton <riton@riton.home>
Date:   Mon Jul 14 21:43:42 2025 +0300

    seperate deftest from test instances

commit 92d20e0b8405a4a51f01ff65f8bd81f4d25c1e21
Author: riton <riton@riton.home>
Date:   Mon Jul 14 21:29:47 2025 +0300

    make a test system definition

commit 125e5fe1e8c07230f32e762273c5c0dd259209e6
Author: riton <riton@riton.home>
Date:   Mon Jul 14 00:39:09 2025 +0300

    compiler macro of as-token

commit 0e39c32097783aa39e3fed479bb85b412065f597
Author: riton <riton@riton.home>
Date:   Mon Jul 14 00:21:46 2025 +0300

    define new packages

1 files changed, 24 insertions, 24 deletions

diff --git a/src/lexer.lisp b/src/lexer.lisp
index 8694aa1..3dffc7c 100644
--- a/src/lexer.lisp
+++ b/src/lexer.lisp
@@ -1,4 +1,4 @@
-(in-package :monkey)
+(in-package :lexer)
 
 (defparameter *eof* (code-char 0))
 
@@ -29,7 +29,7 @@
    (ch :accessor ch)
    (peek-ch :accessor peek-ch)))
 
-(defun make-lexer (input-string &optional len)
+(defun make (input-string &optional len)
   (let ((l (make-instance 'lexer :input input-string
                                  :length (if (not (null len))
                                              len
@@ -67,35 +67,35 @@
     (prog1 (case (ch l)
              (#\= (cond ((char= #\= (lexer-peek l))
                          (lexer-read l)
-                         (make-token :t/== "=="))
+                         (token:as-token :t/==))
                         (t ;;(whitespace? (lexer-peek l))
-                         (make-token :t/= (ch l)))))
-             (#\+ (make-token :t/+ (ch l)))
-             (#\- (make-token :t/- (ch l)))
+                         (token:as-token :t/=))))
+             (#\+ (token:as-token :t/+))
+             (#\- (token:as-token :t/-))
              (#\! (cond ((char= #\= (lexer-peek l))
                          (lexer-read l)
-                         (make-token :t/!= "!="))
+                         (token:as-token :t/!=))
                         (t ;; (whitespace? (lexer-peek l))
-                         (make-token :t/! (ch l)))))
-             (#\/ (make-token :t// (ch l)))
-             (#\* (make-token :t/* (ch l)))
-             (#\< (make-token :t/< (ch l)))
-             (#\> (make-token :t/> (ch l)))
-             (#\; (make-token :t/semicolon (ch l)))
-             (#\, (make-token :t/comma (ch l)))
-             (#\( (make-token :t/lparen (ch l)))
-             (#\) (make-token :t/rparen (ch l)))
-             (#\{ (make-token :t/lbrace (ch l)))
-             (#\} (make-token :t/rbrace (ch l)))
+                         (token:as-token :t/!))))
+             (#\/ (token:as-token :t//))
+             (#\* (token:as-token :t/*))
+             (#\< (token:as-token :t/<))
+             (#\> (token:as-token :t/>))
+             (#\; (token:as-token :t/semicolon))
+             (#\, (token:as-token :t/comma))
+             (#\( (token:as-token :t/lparen))
+             (#\) (token:as-token :t/rparen))
+             (#\{ (token:as-token :t/lbrace))
+             (#\} (token:as-token :t/rbrace))
              (otherwise (cond ((eof? (ch l))
-                               (make-token :t/eof ""))
+                               (token:as-token :t/eof))
                               ((letter? (ch l))
                                (let ((literal (read-identifier l)))
-                                 (return (make-token (lookup-identifier literal)
+                                 (return (token:make (token:lookup-identifier literal)
                                                      literal))))
                               ((digit? (ch l))
-                               (return (make-token :t/int (read-number l))))
-                              (t (make-token :t/illegal "ILLEGAL")))))
+                               (return (token:make :t/int (read-number l))))
+                              (t (token:make :t/illegal "ILLEGAL")))))
       (lexer-read l))))
 
 (defmethod read-number ((l lexer))
@@ -113,8 +113,8 @@
     (make-string-view (input l) start (pos l))))
 
 
-(defmethod lexer-tokens ((l lexer))
+(defmethod lex ((l lexer))
   (loop :for token := (next-token l)
         :collect token
-        :until (eq :t/eof (_type token))))
+        :until (token:type-is token :t/eof)))