Adjust lispy--function-parse to a new object representation.

* lispy.el (lispy--function-parse): Update function to a newer object
representation.  Fix `lispy-flatten'.

In Emacs 30, it began to use dedicated type to represent
interpreted-function values, `read' function now returns Closure
Function Type instead of simple lists for most types that
`lispy--function-parse' tries to handle (except macros, at least).

See:
- https://git.sv.gnu.org/cgit/emacs.git/commit/?id=f2bccae22bd47a2e7e0937b78ea06131711b935a
- (elisp) Closure Type
- (elisp) Closure Objects

Compare

    (defmacro test-macro (&rest body)
      ,@Body)
    (symbol-function 'test-macro)
    ;; (macro . #[(&rest body) ((\,@ body)) (t)])

with

(defun test-defun (x)
  (+ x 1))
(symbol-function 'test-defun)
;; #[(x) ((+ x 1)) (t)]

There's alternative way to mitigate it, by changing
end of `lispy--function-str' to:

        (error
         (let ((str (cl-prin1-to-string (symbol-function fun))))
           (if (string-prefix-p "#f" str)
               (substring str 2)
             str)))

But it hides the underlying change that needs to be addresed in the
future.

Partially fixes `lispy-let-flatten' as well, but keywords (&optional,
&rest) in function's signature are not recognized correctly.

Author: EugeneNeuron

lispy.el

@@ -7640,42 +7640,48 @@ Defaults to `error'."
 (defun lispy--function-parse (str)
   "Extract the function body and args from it's expression STR."
   (let ((body (lispy--read str))
-        args)
-    (cond ((eq (car body) 'lambda)
-           (setq body (cons 'defun body)))
-          ((eq (car body) 'closure)
-           (setq body `(defun noname ,@(cddr body))))
-          ((eq (car body) 'defsubst)
-           (setq body (cons 'defun (cdr body)))))
-    (cond ((memq (car body) '(defun defmacro))
-           (setq body (lispy--whitespace-trim (cdr body))))
-          ((eq (car body) 'defalias)
-           (let ((name (cadr (cadr (read str)))))
-             (setq body
-                   (cons name (cdr (symbol-function name))))))
-          (t
-           (error "Expected defun, defmacro, or defalias got %s" (car body))))
-    (if (symbolp (car body))
-        (setq body (lispy--whitespace-trim (cdr body)))
-      (error "Expected function name, got %s" (car body)))
-    (if (listp (car body))
-        (progn
-          (setq args (car body))
+	args)
+    (if (not (consp body))
+        (progn (setq args (aref body 0))
+               (setq body (aref body 1)))
+      ;; In Emacs 30, `read' returns a dedicated type, instead of
+      ;; simple list, for lambdas, defuns, closures, etc.  And code
+      ;; below is only valid for `defmacro'.  Keep it for Emacs < 30.
+      (cond ((eq (car body) 'lambda)
+             (setq body (cons 'defun body)))
+            ((eq (car body) 'closure)
+             (setq body `(defun noname ,@(cddr body))))
+            ((eq (car body) 'defsubst)
+             (setq body (cons 'defun (cdr body)))))
+      (cond ((memq (car body) '(defun defmacro))
+             (setq body (lispy--whitespace-trim (cdr body))))
+            ((eq (car body) 'defalias)
+             (let ((name (cadr (cadr (read str)))))
+               (setq body
+                     (cons name (cdr (symbol-function name))))))
+            (t
+             (error "Expected defun, defmacro, or defalias got %s" (car body))))
+      (if (symbolp (car body))
+          (setq body (lispy--whitespace-trim (cdr body)))
+        (error "Expected function name, got %s" (car body)))
+      (if (listp (car body))
+          (progn
+            (setq args (car body))
+            (setq body (lispy--whitespace-trim (cdr body))))
+        (error "Expected function arguments, got %s" (car body)))
+      ;; skip docstring
+      (if (and (listp (car body))
+               (eq (caar body) 'ly-raw)
+               (eq (cadar body) 'string))
+          (setq body (lispy--whitespace-trim (cdr body))))
+      ;; skip declare
+      (if (and (listp (car body))
+               (eq (caar body) 'declare))
           (setq body (lispy--whitespace-trim (cdr body))))
-      (error "Expected function arguments, got %s" (car body)))
-    ;; skip docstring
-    (if (and (listp (car body))
-             (eq (caar body) 'ly-raw)
-             (eq (cadar body) 'string))
-        (setq body (lispy--whitespace-trim (cdr body))))
-    ;; skip declare
-    (if (and (listp (car body))
-             (eq (caar body) 'declare))
-        (setq body (lispy--whitespace-trim (cdr body))))
-    ;; skip interactive
-    (if (and (listp (car body))
-             (eq (caar body) 'interactive))
-        (setq body (lispy--whitespace-trim (cdr body))))
+      ;; skip interactive
+      (if (and (listp (car body))
+               (eq (caar body) 'interactive))
+          (setq body (lispy--whitespace-trim (cdr body)))))
     (list args body)))
 
 (defun lispy--flatten-function (fstr e-args)