Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class DaniellCellScene(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Scene title
        # 2. Diagram: Combination of Rectangle, Circle, Line, Arrow - .shift(LEFT * 2.5) - Daniell cell diagram left side
        # 3. Explanation Text: Text - .shift(RIGHT * 2.5) - Explanation of components and reactions right side
        # 4. Main Equation: MathTex - .shift(UP * 1.5) - Half reactions and overall reaction (shown last)
        # 5. Secondary Text: Text - .shift(DOWN * 1.5) - Transition text (shown last)

        # 1. Title
        title = Text("Daniell Cell: Concept & Structure", color=WHITE).to_edge(UP, buff=0.5)

        # 2. Diagram Construction (Left side)
        # Zinc electrode (Rectangle BLUE), ZnSO4 solution (Rectangle BLUE with label)
        zinc_electrode = Rectangle(width=0.6, height=1.5, color=BLUE).shift(LEFT * 2.5 + UP * 0.5)
        zinc_label = Text("Zn Electrode", color=BLUE).next_to(zinc_electrode, DOWN, buff=0.1)
        znso4_solution = Rectangle(width=1.2, height=1.5, color=BLUE).next_to(zinc_electrode, RIGHT, buff=0.1)
        znso4_label = Text("ZnSO₄ Solution", color=BLUE).next_to(znso4_solution, DOWN, buff=0.1)

        # Copper electrode (Rectangle RED), CuSO4 solution (Rectangle RED with label)
        copper_electrode = Rectangle(width=0.6, height=1.5, color=RED).shift(LEFT * 0.5 + UP * 0.5)
        copper_label = Text("Cu Electrode", color=RED).next_to(copper_electrode, DOWN, buff=0.1)
        cuso4_solution = Rectangle(width=1.2, height=1.5, color=RED).next_to(copper_electrode, RIGHT, buff=0.1)
        cuso4_label = Text("CuSO₄ Solution", color=RED).next_to(cuso4_solution, DOWN, buff=0.1)

        # Salt bridge (Rectangle GREEN) connecting the two solutions
        salt_bridge = Rectangle(width=0.3, height=1.5, color=GREEN).next_to(znso4_solution, RIGHT, buff=0.1)

        # Electrodes and solutions grouped for animation
        diagram_group = VGroup(
            zinc_electrode, zinc_label, znso4_solution, znso4_label,
            salt_bridge,
            copper_electrode, copper_label, cuso4_solution, cuso4_label
        )

        diagram_group.shift(LEFT * 2.5)

        # 3. Explanation Text (Right side)
        explanation_lines = [
            "Components:",
            "- Zinc electrode in ZnSO₄ solution",
            "- Copper electrode in CuSO₄ solution",
            "- Salt bridge connects the two solutions",
            "",
            "Reactions:",
            "Oxidation at Zn anode -> Zn -> Zn²⁺ + 2e⁻",
            "Reduction at Cu cathode -> Cu²⁺ + 2e⁻ -> Cu",
            "Electron flow through external circuit"
        ]
        explanation_text = VGroup(*[
            Text(line, color=WHITE, font_size=24) for line in explanation_lines
        ]).arrange(DOWN, aligned_edge=LEFT).shift(RIGHT * 2.5 + UP * 0.5)

        # Animation sequence step 1: Show title and diagram with explanation
        self.play(Write(title), run_time=1.5)
        self.play(Create(diagram_group), run_time=2)
        self.play(Write(explanation_text), run_time=3)

        # Pause briefly
        self.wait(1)

        # Cleanup step 1: Fade out diagram and explanation, keep title
        self.play(FadeOut(diagram_group), FadeOut(explanation_text), run_time=1.5)

        # 4. Main Equation (Upper center)
        # Half reactions and overall reaction in simple_equation pattern
        half_reaction_oxidation = MathTex(
            r"\text{Zn} \to \text{Zn}^{2+} + 2e^-", color=BLUE
        )
        half_reaction_reduction = MathTex(
            r"\text{Cu}^{2+} + 2e^- \to \text{Cu}", color=RED
        )
        overall_reaction = MathTex(
            r"\text{Zn} + \text{Cu}^{2+} \to \text{Zn}^{2+} + \text{Cu}", color=YELLOW
        )

        # Arrange equations vertically, center upper part
        equations_group = VGroup(
            half_reaction_oxidation,
            half_reaction_reduction,
            overall_reaction
        ).arrange(DOWN, buff=0.5).shift(UP * 1.5)

        # 5. Secondary Text (Lower center)
        transition_text = Text(
            "Having understood the physical setup and basic operation,\n"
            "next we explore the half-reactions and overall cell reaction mathematically.",
            color=WHITE,
            font_size=24
        ).shift(DOWN * 1.5)

        # Animation sequence step 2: Show main equations and transition text
        self.play(Write(half_reaction_oxidation), run_time=1.5)
        self.wait(0.5)
        self.play(Write(half_reaction_reduction), run_time=1.5)
        self.wait(0.5)
        self.play(Write(overall_reaction), run_time=1.5)
        self.wait(0.5)
        self.play(Write(transition_text), run_time=2)

        # Final pause
        self.wait(2)

        # Final cleanup: Fade out title and transition text, keep main equations visible
        self.play(FadeOut(title), FadeOut(transition_text), run_time=1.5)

        # End scene with main equations visible
        self.wait(2)
```
---

### Explanation

- **Title** is positioned `.to_edge(UP, buff=0.5)` as required.
- **Diagram** (electrodes, solutions, salt bridge) grouped and shifted `.shift(LEFT * 2.5)` on left side.
- **Explanation text** is grouped and shifted `.shift(RIGHT * 2.5)` on right side.
- **Main equations** (half reactions and overall reaction) arranged vertically and shifted `.shift(UP * 1.5)` at upper center.
- **Transition text** is `.shift(DOWN * 1.5)` at lower center.
- All elements fit within the screen bounds.
- Only allowed Manim objects and colors are used.
- Animations are only Write, Create, FadeIn, FadeOut.
- Cleanup rules are followed: fade out old elements before new ones, keep main equations visible at the end.
- The pattern is simple_equation for the math part.
- The scene is simple, clear, and strictly follows positioning rules.
PATTERN: simple_equation

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 positioned at top
        title = Text("{title}").scale(0.7).to_edge(UP, buff=0.5)
        
        # Main equation in center
        equation = MathTex(r"{equation}").scale(0.8)
        
        # Description below equation
        description = Text("{description}").scale(0.4).shift(DOWN * 2)
        
        # Simple highlight
        highlight = SurroundingRectangle(equation, color=YELLOW, buff=0.2)
        
        # Progressive animation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(equation))
        self.wait(1)
        self.play(Create(highlight))
        self.wait(1)
        self.play(FadeOut(highlight))
        self.play(Write(description))
        self.wait(2)
            

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

Generate complete Python code: