Since DSolve[] won't solve the eigenvalue problem by itself, one has to use Solve[] or something else to finish the job. Of course, there are different approaches and stages where one might do that. Given the general solution to a linear ODE, the boundary conditions (BCs) lead to a linear problem plus a condition that defines the eigenvalues. The extra condition is usually nonlinear, which might complicate solving the problem. In the OP's example, it's a trigonometric equation that is readily solved.

DSolve[] will try to solve eigenvalue problems when there are exactly two boundary conditions, but that's not the case in the problem at hand. Since there are four BCs, DSolve[] solves the system as a BVP, treating mu as a fixed parameter.

Note that the harmonic oscillator equation is handled as a special case by the eigenvalue-problem solver in DSolve[]. One advantage of the special handling is that you get one family of eigenvalues, instead of the two families that Solve[] and Reduce[] usually return when you solve Sin[u] == 0, one for u == 2n Pi (even multiplies) and one for u == (2n+1) Pi (odd multiples). In the approach below, we get two families of these types.

solToFunction = # /. {y_[x__] -> val_} :> {y -> Function[{x}, val]} &; (* utility *)

(* Set up the problem *)
ClearAll[yy, x, l, \[Mu]];
ode = yy''''[x] + \[Mu]^2 yy''[x] == 0;
bcs = {yy[0] == 0, yy[l] == 0, yy''[0] == 0, yy''[l] == 0};
(* get general solution *)
gensol = DSolve[ode, yy[x], x];
(* matrix of linear system from BCs == Part [[2]] *)
bcsys = CoefficientArrays[
    Subtract @@@ First[bcs /. solToFunction@gensol], Array[C, 4]][[2]];
(* solve the boundary conditions *)
bcsol = Simplify[
    Reduce[{
      bcsys . Array[C, 4] == {0, 0, 0, 0}, (* solve for nullspace *)
      Det[bcsys] == 0},(* nontrivial nullspace/eigenvalue condition *)
     Array[C, 4]],
    l > 0 && \[Mu] > 0] // (* extra conditions *)
   (* solve for parameter mu and whichever C[k]'s Solve can *)
   Solve[#, Array[C, 4]~Append~\[Mu]] &;
First[gensol] /. bcsol (* plug in values of parameters *)

Solve::svars: Equations may not give solutions for all "solve" variables.

The warning message is because Solve[] cannot solve for all the C[k] parameters of integration (C[2] in this case). That is, of course, exactly what we want to have happen.

I guess I could add that DSolve[] treats μ as a given parameter, not as an unknown to be solved for. The only solution that is generically true — that is, true for almost all values of μ and l — is the trivial solution. You have to take special steps, such as you've shown, to solve the eigenvalue problem. Was that what you were trying to demonstrate?

To follow up on my remark about DSolve[] not solving for parameters, if one makes mu a dependent variable, then DSolve[] will solve for it. This can be done by replacing μ by μ[x] and adding the differential equation μ'[x] == 0. Unfortunately, the default solver uses inverse functions in this case. That yields only one solution, the trivial solution, instead of all solutions:

ode = yy''''[x] + \[Mu]^2 yy''[x] == 0;
bcs = {yy[0] == 0, yy[l] == 0, yy''[0] == 0, yy''[l] == 0};
DSolve[{ode /. \[Mu] -> \[Mu][x], \[Mu]'[x] == 0, bcs}, {yy[x], \[Mu][x]}, x,
 Assumptions -> \[Mu][x] > 0 && l > 0]

(*  `DSolve::ifun`: Inverse functions are being used by DSolve, so some solutions may not be found.  *)
(*  {{yy[x] -> 0, \[Mu][x] -> C[1]}}  *)

However, we can use what is often called the Villegas-Gayley trick to adjust how Solve[] works:

Internal`InheritedBlock[{Solve},
 Unprotect[Solve];
 Solve[eq_, v_, opts___] /; ! TrueQ[$in] := Block[{$in = True},
   Simplify@Solve[Flatten@{eq, $Assumptions}, v, Method -> Reduce, opts]];
 Protect[Solve];
 DSolve[{ode /. \[Mu] -> \[Mu][x], \[Mu]'[x] == 0, bcs}, {yy[x], \[Mu][x]}, x,
  Assumptions -> \[Mu][x] > 0 && l > 0 && C[1] > 0]
 ]
(*
{{yy[x] -> 0, \[Mu][x] -> C[1]}, 
  {yy[x] -> ConditionalExpression[
     -((l^3*C[3] Sin[(2*Pi*x*C[6])/l])/(8*Pi^3*C[6]^3)),
     Element[C[6], Integers] && C[6] >= 1], 
   \[Mu][x] -> ConditionalExpression[
     (2*Pi*C[6])/l, 
     Element[C[6], Integers] && C[6] >= 1]}, 
  {yy[x] -> ConditionalExpression[
     -((l^3*C[3] Sin[(x*(Pi + 2*Pi*C[6]))/l])/(Pi^3*(1 + 2*C[6])^3)), 
     Element[C[6], Integers] && C[6] >= 0], 
   \[Mu][x] -> ConditionalExpression[
     (Pi + 2*Pi*C[6])/l, 
     Element[C[6], Integers] && C[6] >= 0]}}
*)

The extra condition C[1] > 0 is not necessary but simplifies the output. It was added as an afterthought, after seeing \[Mu][x] was solved as \[Mu][x] -> C[1] in terms of C[1]. The assumption \[Mu][x] > 0 is not automatically extended to include C[1].

One could simplify the values in the solution to C[3] Sin[2 π x C[6] / l] and C[3] Sin[x (π + 2 π C[6]) / l], if one wanted to. A general code to do so takes some work.

This post is tagged as a question, and the title is a question; but the code seems to be a solution. Is it good enough, or are you looking for some kind of help?