>>5
funcall doesn't look into the other namespace.
funcall/apply are just functions.
(funcall fun arg1 arg2 ... argn) is just a normal function call, which means, fun and the arguments are evaluated in order, and their values(!) are passed to the funcall function. That funcall call would be valid if fun had a functional value by itself, like
(let ((fun (lambda () 123))) (funcall fun))=>3
On the other hand, (let ((fun (lambda () 123))) (funcall #'fun)) would throw an error, unless there was a local (or non-local) function named fun. #'stuff is just a dispatch macro character for (function stuff). (function stuff) would look up the symbol stuff in the local environment and return the functional value associated with that symbol (a symbol is actually a more complex object with a few fields, such as a name(string), home package, value and functional value).
In short, APPLY/FUNCALL are just functions which just evaluate their arguments in order, like all functions. You are passing
values to any normal function call (not a macro or a special operator). If you'd like to pass a value from the functional namespace, you have to use #' or
(function ...). (There are other ways to get the functional value of a symbol, such as symbol-function or fdefinition, but those are more complex topics, though it would probably make it simpler to understand). This is actually much simpler than I'm making it sound. One final consideration, the first element(the car of the form) is always taken from the functional namespace(or it's a macro or special form, but those topics are slightly more complex, so you can ignore them until you reach them), while the rest are just plain values.
P.S.: An example where the previous example would be valid with #' is
(flet ((fun () 123)) (funcall #'fun)) ;=>123
What do you think the result of this would be:
(flet ((fun () 123))
(let ((fun #'(lambda () #'fun)))
(funcall (funcall fun)))) ;=> [spoiler]123[/spoiler]
If you still have any questions, it will probably become clear when you learn symbols, packages and environments in more detail. I would also suggest you test everything in your implementation of choice and use a good inspector package along with Emacs+SLIME, it would surely clear up a lot of details about how things work under the hood and maybe give you an easier way to gain understanding if reading books or the standard is too cumbersome for you.