Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class LinearSearchConcept(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Diagram: Rectangle array + highlighted element (Rectangle + SurroundingRectangle) - .shift(LEFT * 2.5) - Visual focus on list with highlighted element
        # 3. Explanation Text: Text - .shift(DOWN * 1.5) - Content explaining linear search

        # 1. Title
        title = Text("Linear Search Algorithm").to_edge(UP, buff=0.5).set_color(WHITE)

        # 2. Diagram of simple list (array) with element highlighted
        # Create 5 rectangles representing array elements
        rects = VGroup(*[
            Rectangle(width=1, height=1, stroke_color=WHITE) for _ in range(5)
        ]).arrange(RIGHT, buff=0.2).shift(LEFT * 2.5)
        # Add numbers inside rectangles (MathTex)
        elements = VGroup(*[
            MathTex(str(x)).move_to(rects[x].get_center()) for x in range(5)
        ])
        # Highlight 3rd element (index 2)
        highlight = SurroundingRectangle(rects[2], color=YELLOW, buff=0.1)

        # 3. Explanation Text (secondary text)
        explanation = Text(
            "Linear search checks each element sequentially\n"
            "from start to end to find the target.\n"
            "Works on sorted and unsorted lists.",
            t2c={"Linear search": BLUE, "sequentially": GREEN, "sorted and unsorted": RED}
        ).scale(0.7).shift(DOWN * 1.5).set_color(WHITE)

        # Animation Sequence:

        # Step 1: Show title
        self.play(Write(title), run_time=1.5)

        # Step 2: Show diagram with highlighted element
        self.play(Create(rects), Write(elements), Create(highlight), run_time=2)
        # Keep title and diagram, fade out explanation if any (none yet)

        # Step 3: Show explanation text below
        self.play(Write(explanation), run_time=2)
        # Keep title, diagram, explanation visible

        # Step 4: Transition text (secondary text)
        transition_text = Text(
            "Having understood what linear search is,\n"
            "next we will explore how the algorithm works step-by-step.",
            t2c={"linear search": BLUE}
        ).scale(0.7).shift(DOWN * 1.5).set_color(WHITE)

        # Fade out explanation, fade in transition text
        self.play(FadeOut(explanation), Write(transition_text), run_time=2)

        # Final cleanup: fade out highlights and transition text, keep title and diagram visible
        self.play(FadeOut(highlight), FadeOut(transition_text), run_time=1.5)
```

PATTERN: step_progression

CRITICAL CONSTRAINTS:
1. Use ONLY these objects: Text, MathTex, Axes, Circle, Rectangle, Line, Arrow, Dot, SurroundingRectangle, VGroup
2. Use ONLY these animations: Write, Create, FadeIn, FadeOut 
3. Use ONLY these colors (no quotes): BLUE, RED, GREEN, YELLOW, WHITE, ORANGE, PURPLE
4. NO undefined objects like VideoFile, Slider, ImageMobject
5. NO Unicode characters - use LaTeX: \sqrt{} not √, \pm not ±

POSITIONING REQUIREMENTS (CRITICAL):
- Each element MUST have unique position within screen bounds
- SAFE positions only: .to_edge(UP), .shift(UP*1.5), .shift(DOWN*1.5), .shift(LEFT*2.5), .shift(RIGHT*2.5)
- NO extreme shifts: avoid UP*3, DOWN*3, LEFT*4, RIGHT*4 (goes off-screen)
- NO overlapping: if one element uses .shift(UP*1.5), others must use different positions
- Test positions: Title=top, Main=upper center, Secondary=lower center, Sides=left/right

TEMPLATE TO ADAPT:

        # Title at top
        title = Text("{title}").scale(0.8).to_edge(UP, buff=0.5)
        
        # Step equations positioned vertically
        step1 = MathTex(r"{step1}").shift(UP * 2)
        step2 = MathTex(r"{step2}").shift(UP * 0.5)  
        step3 = MathTex(r"{step3}").shift(DOWN * 1)
        
        # Step labels on the right
        label1 = Text("{label1}").scale(0.5).shift(RIGHT * 4 + UP * 2)
        label2 = Text("{label2}").scale(0.5).shift(RIGHT * 4 + UP * 0.5)
        label3 = Text("{label3}").scale(0.5).shift(RIGHT * 4 + DOWN * 1)
        
        # Progressive revelation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(step1))
        self.wait(1)
        self.play(Write(label1))
        self.wait(1)
        self.play(Write(step2))
        self.wait(1)
        self.play(Write(label2))
        self.wait(1)
        self.play(Write(step3))
        self.wait(1)
        self.play(Write(label3))
        self.wait(2)
                

Replace placeholders with scene-specific values and ensure working Manim code.

Generate complete Python code:
SMART POSITIONING REQUIREMENTS:
- Analyze the content TYPE first: equation, diagram, comparison, process
- Position based on content meaning, not just arbitrary rules
- Main subject (equation/diagram) should be CENTER or slightly UP
- Supporting text should be BELOW the main subject
- Comparisons should use LEFT/RIGHT positioning
- Sequential content should use TOP-to-BOTTOM flow
- NEVER fade out main content - only temporary highlights

CAREFULLY IMPLEMENT THIS