Lisp

Your markdown is making me a sad panda.

Why must the variable c be declared outside and before the function definition my-counter!.
[ If you put it inside the value is always "reset"]

In Common Lisp, as opposed to Scheme, it is not possible that the car of the compound form to be evaluated is an arbitrary form. If it is not a symbol, it must be a lambda expression, which looks like (lambda lambda-list form*).

This

funcall isn't needed, because in your snippet defun-ed f.

funcall for defvar lambdas in CL.

Scheme is a Lisp-1 -> variables and procedures are defined in one namespace.

In CL (Lisp-2) variables and functions separated.

You shouldn't need funcall in your common lisp code, but the way you defined your function requires it. You have

(let ((c 0))
  (defun my-counter! ()
    (lambda ()
      (setf c (+ 1 c))
      c)))

defun already defines a function; you don't need to also wrap the function body in a lambda. This definition allows you to avoid the funcall:

(let ((c 0))
  (defun my-counter! ()
    (setf c (+ 1 c))
    c))

Though it's worth knowing that unlike in scheme, common lisp will return the value after a setf. There's also a convenience macro called incf that increments variables so you can write the whole thing like this:

(let ((c 0))
  (defun my-counter! ()
    (incf c)))

And your other question: Why the different placing of the let?

In common lisp, defun, defvar, defparameter, defmacro, ... all affect global scope, no matter where they appear. scheme's define does not affect global scope; its effects are only visible locally. This means that a defun inside of a let body still creates a globally accessible function that closes over the variables defined in the let bindings. Scheme, by contrast, needs to have a define at global level (or at least outside the let) but the function body still needs to close over the let variables.