Make macro expander a little bit efficient.

This argument will not be used for object-like macro.
Allocating a new object is just a waste.
Rename special_macro_handler -> SpecialMacroHandler.

Type name is in camel case in 8cc convention.
Fix macro expander for ##.

Usually a macro argument is expanded repeatedly until it cannot
be expanded anymore, and then the entire resulting token string
is expanded again (until they can't be expanded anymore).

I(A B) in the following example is expanded to "1 2" because A B
are expanded repeatedly until they eventually expanded to 1 2.

 #define S(x) #x
 #define I(x) S(x)
 #define A 1
 #define B 2

 I(A B) -> S(A B) -> S(1 2) -> "1 2"

However, if an argument follows ##, that expansion won't take place.
Instead, the first token of the argument is pasted to the previous
token, and that token and the rest tokens are just added to the result.
And then the entire resulting token string will be expanded repeatedly.

That difference in expansion order causes subtle difference.
J(A B) in the following example is expanded to "fooA b".

 #define S(x) #x
 #define J(x) S(foo ## x)  // foo is a free identifier
 #define A 1
 #define B 2

 J(A B) -> S(fooA B) -> "fooA B"

I don't know why this behavior is required. It seems unnecessarily
complicated. Maybe there's no reason, but it's just that everybody
implements the C preprocessor in the way as described in Dave
Prosser's document.
https://github.com/rui314/8cc/wiki/cpp.algo.pdf
Simplify.