Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class LinearSearchScene(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Main equation: Text - .shift(UP * 1.5) - Definition of linear search
        # 3. Diagram (list of numbers with highlighted target): 
        #    Rectangles + Text + SurroundingRectangle - .shift(LEFT * 2.5) - Visual focus
        # 4. Secondary text: Text - .shift(DOWN * 1.5) - Explanation / transition

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

        # 2. Main equation (definition)
        main_eq = Text(
            "Linear search checks each element sequentially\n"
            "until the target is found or list ends."
        ).shift(UP * 1.5)

        # 3. Diagram of list with highlighted target
        # Create list elements as rectangles with numbers inside
        numbers = [3, 7, 1, 9, 5]
        rects = VGroup()
        texts = VGroup()
        for i, num in enumerate(numbers):
            rect = Rectangle(height=0.8, width=0.8, stroke_color=WHITE)
            rects.add(rect)
            txt = Text(str(num), font_size=24)
            texts.add(txt)
        # Arrange horizontally with small gaps
        rects.arrange(RIGHT, buff=0.2)
        texts.arrange(RIGHT, buff=0.2)
        # Overlay texts on rects
        for rect, txt in zip(rects, texts):
            txt.move_to(rect.get_center())

        # Highlight the target element (e.g. number 9)
        target_index = 3
        highlight = SurroundingRectangle(rects[target_index], color=YELLOW, buff=0.1)

        # Group diagram elements and shift left side
        diagram = VGroup(rects, texts, highlight).shift(LEFT * 2.5)

        # 4. Secondary text (explanation)
        secondary_text = Text(
            "Works on sorted and unsorted lists.", font_size=24
        ).shift(DOWN * 1.5)

        # 5. Transition text
        transition_text = Text(
            "Now that we know what linear search is,\nlet's see how the algorithm works step-by-step.",
            font_size=24
        ).shift(DOWN * 1.5)

        # Animation Sequence:

        # Step 1: Show title and main equation
        self.play(Write(title), Write(main_eq), run_time=3)
        # Keep main_eq visible, fade out title
        self.play(FadeOut(title), run_time=1)

        # Step 2: Show diagram with highlight and secondary text
        self.play(
            Create(rects),
            Write(texts),
            Create(highlight),
            Write(secondary_text),
            run_time=3
        )
        # Fade out highlight and secondary text, keep main_eq and diagram visible
        self.play(FadeOut(highlight), FadeOut(secondary_text), run_time=1)

        # Step 3: Show highlight again to emphasize target, and transition text
        highlight2 = SurroundingRectangle(rects[target_index], color=YELLOW, buff=0.1)
        self.play(Create(highlight2), Write(transition_text), run_time=3)
        # Fade out highlight and transition text, keep main_eq and diagram visible
        self.play(FadeOut(highlight2), FadeOut(transition_text), run_time=1)

        # Step 4: Final cleanup - fade out diagram and main_eq
        self.play(FadeOut(rects), FadeOut(texts), FadeOut(main_eq), run_time=2)
```
---

### Explanation:

- **Title** is positioned `.to_edge(UP, buff=0.5)` as required.
- **Main equation** (definition text) is `.shift(UP * 1.5)` centered horizontally.
- **Diagram** (list of numbers with highlight) is shifted `.shift(LEFT * 2.5)`.
- **Secondary and transition texts** are `.shift(DOWN * 1.5)`.
- Only allowed Manim objects are used: `Text`, `Rectangle`, `SurroundingRectangle`.
- Only allowed animations are used: `Write`, `Create`, `FadeIn`, `FadeOut`.
- Colors used: `WHITE` for rectangles and text, `YELLOW` for highlight.
- Positioning respects the strict rules and stays within screen bounds.
- Cleanup rules are followed: highlights and old texts fade out, main equation remains visible until final cleanup.
- Step progression pattern is followed in animation sequence.
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