Help with Scripting Animations?

There are actually a few ways to tween CFrames, but to keep things simple let's just keep it to what you suggested, linear interpolation (LERP).

The basic math behind lerping is:

-- a is start, b is end, c is the percentage between the two
function lerp(a, b, c)
	return a + ((b - a) * c);
end;

With this basic equation we can get a value between two points linearly. Now some clarification, linear doesn't mean the way we change c (as I'll explain in a bit), but rather that we essentially get from point a to be in a straight line. From a number standpoint this doesn't make much sense, but once we get into 3D this can become convoluted. Regardless, that's a topic for another time (google SLERP if you dare :P)

Right, so now that we understand the basis of lerping let's make our own CFrame lerp function:

function lerpCf(a, b, c)
	local newCf = {};
	local a, b = {a:components()}, {b:components()};
	for i = 1, 12 do -- 12 components in a CFrame
		newCf[i] = a[i] + ((b[i] - a[i]) * c); -- lerp equation
	end;
	return CFrame.new(unpack(newCf));
end;

Now luckily for us, Roblox has a built in lerp method (that I think might be more accurate(?)) so we don't have to have this function in our code. That being said, it's still useful to understand it.

So onto the tween. We have 3 pieces of information. The start CFrame, the end CFrame, and the time. So taking a look at that information and what we need for a lerp what are we missing? -- The c-value our percentage!

The question becomes how do we translate our time into that c-percentage? The answer is to use tick:

function tweenCf(child, property, goal, t)
	local start = child[property];
	local stime, ctime = tick(), 0;
	while ctime < t do -- keep updating as long as time passed is < the tween length
		ctime = (tick() - stime); -- how much time has passed
		child[property] = start:lerp(goal, ctime/t); -- percentage of current time passed
		wait(0); -- use renderstepped if you can
	end;
	child[property] = goal; -- set to the goal value incase of float math errors, etc
end;

Now as mentioned above, we can also change how we handle the c-value by playing with what are called easing functions. They essentially change how the c-value move. Eg. It might be really fast at the start and slow down at the end, but it'll still add up to t seconds passed.

Here's an example:

function tweenCf(child, property, goal, t, ease)
	local start = child[property];
	local stime, ctime = tick(), 0;
	while ctime < t do
		ctime = (tick() - stime);
		child[property] = start:lerp(goal, ease(ctime, 0, 1, t)); -- easing function
		wait(0);
	end;
	child[property] = goal;
end;

function inOutQuad(t, b, c, d)
	t = t / d * 2;
	if t < 1 then
		return c / 2 * math.pow(t, 2) + b;
	else
		return -c / 2 * ((t - 1) * (t - 3) - 1) + b;
	end;
end;

local part = game.Workspace.Part;
tweenCf(part, "CFrame", CFrame.new(15, 15, 15) * CFrame.Angles(math.pi/4, math.pi/4, math.pi/4), 2, inOutQuad);

Here's a bit list of easing functions pre-written! https://github.com/EmmanuelOga/easing/blob/master/lib/easing.lua