Q:

Spooky haskell function that somehow knows your input

How can sumListV3 function? myFoldr requires 3 args: function, base case num, and list. Yet it somehow knows the list (based on your input) even though it was never specified in the internal code.
I think sumListV2 is the simplest it can go. How does sumListV3 even compile, let alone function properly?
myFoldr :: (a -> b -> b) -> b -> [a] -> b
myFoldr _ baseCase [] = baseCase
myFoldr f b (x:xs) = f x (myFoldr f b xs)

sumListV2 :: [Int] -> Int
sumListV2 xs = myFoldr (+) 0 xs

sumListV3 :: [Int] -> Int
sumListV3 = myFoldr (+) 0 

A:

Functions in Haskell are "curried".
This means that when you have a function f :: a -> b -> c, it's really a -> (b -> c), and f a b is really (f a) b (because of associativity rules).
So when you run f a b, it first does f a, which returns a new function of type b -> c.  You can then give it a b and get your final answer of type c.
This lets you partially apply functions:
ghci> let add :: Int -> Int -> Int ; add a b = a + b
ghci> add 2 3
5
ghci> (add 2) 3
5
ghci> let addToTwo = add 2
ghci> :t addToTwo
addToTwo :: Int -> Int
ghci> addToTwo 6
8
ghci> addToTwo 9
11

What your example for sumListV3 is doing is partially applying myFoldr. (Types here specified to your case.)
myFoldr       :: (Int -> Int -> Int) ->  Int ->  [Int] -> Int
myFoldr       :: (Int -> Int -> Int) -> (Int -> ([Int] -> Int))
myFoldr (+)   ::                         Int -> ([Int] -> Int)
myFoldr (+) 0 ::                                 [Int] -> Int
sumListV3     ::                                 [Int] -> Int

Because sumListV3 is defined as myFoldr (+) 0, you can replace sumListV3 with myFoldr (+) 0 in places where it is called:
sumListV3 [1,2] 
  = (myFoldr (+) 0) [1,2]
  = myFoldr (+) 0 [1,2]

