There's a lot here, and describing what the code does step by step is probably more than can be done here. The code is itself very dense and isn't particularly readible or simple. 

Here's a good resource mentioned elsewhere on how this kind of syntax works. 
http://mathematica.stackexchange.com/a/25616


The entire code is the application of a function:
To an argument:
The code doesn't seem to work by itself which means we'd have to dig apart the manipulate. 

Let me try this step by step from the inside out.

Reduce is a powerful tool to find solutions, but it will return a solution in the form of x==2 or perhaps no solution and it is difficult to extract that 2.
ToRules is the first step to extract that value by then returning the solution in the form x->2.
Next ToRules is inside of { } so the result will either be an empty list if there is no solution or { x->2 }.

Next { ToRules[ ... ] } is inside of [ ]. Things inside of [ ] are arguments to functions, like [ theta ] is the argument for Sin[ theta ].
So the stuff before the [ { ToRules[ ... ] } ] must be a function, even though it might not look as simple as Sin.
We need to understand how all that stuff is just a function and what that function is.
If you carefully match up ( ) and [ ] and { } you see the function starts with (If[ ... and ends with ] & ) but there are two different & and you need the right one.

Using # and & to define a function or #1 and even #2 and & is a shorthand way of defining functions.
If you look at https://reference.wolfram.com/mathematica/ref/Function.html it may not be enough to really understand how this works.
One way of defining a function would be sqr[ x_ ] := x^2; sqr[ 4 ].
A different way of doing this is #1^2&[4] where the #1 acts like the x, the & says it is the end of the function definition and the [ 4 ] is an argument for the function.

So that is what the #1 is, it is telling Mathematica that this is the name of the argument to use in defining this function.

What the code appears to be doing is first test the result from Reduce, if there is no solution then return an empty list.
If there is a solution then create a point using that value and the result of another nested Function[ ] inside all this.
And it uses x /. #1 to extract the value of that solution.

I realize this is a lot to throw at you at once. The first dozen times trying to understand how #1 and & work can be confusing and frustrating.
See if you can match up any parts of this description with parts of the original code.
If you can tell me what parts of this description I have not explained well enough then I'll see if I can do a better job.