Function holds its arguments (evaluate Attributes[Function] to confirm this). So the expression Function[{G0, c0, c1}, Y] is just literally a static expression waiting to be applied to input. Once you input values for the formal symbols G0, c0, and c1, it will try to replace any occurrences of those formal symbols in the body with the values provided. But the expression Y (remember, Y is being held unevaluated at this point) has no such symbols in it, so Y remains unchanged. That Y is then the result of evaluating the Function expression. Then the evaluator looks for transformation rules for Y, and finds the OwnValues you provided, and then that becomes the final expression for the whole evaluation (something like {(-c0 - G0)/(-1 + c1)}).

So, what you need to do is replace the body of the Function expression with the actual value that you assigned to Y. If we could somehow get that Y to evaluate to the definition you provided for it, we'd be set. To force an expression to evaluate when it's being held, you can use Evaluate. So, try defining your function like this:

myFun = Function[{G0, c0, c1}, Evaluate[Y]]

This should output something like this:

Function[{G0, c0, c1}, {(-c0 - G0)/(-1 + c1)}]

which I assume is what you want. And now we can apply our new function:

myFun[5., 1., 0.8]
(* 30. *)

Having said all of this, another way you could avoided this is by not using the intermediate symbol Y and all. You could have just put the LinearSolve expression as the body of your Function. But then the linear solve process would not evaluate until the function was applied to arguments. So it just depends on the evaluation flow you want.

I don't know if you literally want your function to return a list, but if you don't, you can use First instead of Take:

Y = First[LinearSolve[{{1, -1}, {-c1, 1}}, {G0, c0}]]
(* (-c0 - G0)/(-1 + c1) *)

Notice the lack of {}.